﻿#define _CRT_SECURE_NO_WARNINGS 1
#pragma once  //避免头文件重复包含
#include <stdio.h>


//
//#include <stdio.h>
//void main()
//{
//	void print_welcome();    //自定义函数
//	void print_star(int n);
//	print_welcome();
//	print_star(10);
//	printf("\n");
//}
//
//void print_welcome()
//{
//	printf("\n  回忆 \n");
//	printf(" ");
//}
//void print_star(int n)
//{
//	int i;
//	for (i = 0; i < n; i++)
//		putchar('*');
//}



/*
#include <stdio.h>

void swap(int* pa, int* pb)  // 先声明，所设计的swap函数，定义指针变量；*pa=&a
{
	int z = 0;				//所用来交换的桥梁z；
	z = *pa;
	*pa = *pb;
	*pb = z;				//void没有返回值
}

int main()
{
	int a = 10;
	int b = 20;
	printf("交换前的值：a=%d,b=%d\n",a,b);
	swap(&a, &b);			//定义swap函数
	printf("交换后的值：a=%d,b=%d\n",a,b);
		return 0;
}

*/

/*
#include <stdio.h>
int swap(int i, int j)
{
	int a;
	a = i;
	i = j;
	j = a;
	printf("交换前的值：i=%d,j=%d", i, j);
	return i,j;

}
int main()
{
	int i = 2, j = 3;
	swap(i, j);
	printf("交换后的值为：i=%d,j=%d", i, j);
		return 0;
}
*/



//
//int is_leap_year(int n)         // 函数声明  n=year （函参）
//{
//	if ((n % 4 == 0) && (n % 100 != 0) ||( n % 400 == 0))    
//		return 1;      //1 为真，0为假
//	else
//		return 0;
//
//}
//
//#include <stdio.h>
//int main()
//{
//	int is_leap_year(year);      //判断1000到2000里面有哪些是闰年
//	int year = 0;
//	for (year = 1000; year <= 2000; year++)
//	{
//		if (is_leap_year(year))
//		{
//			printf("%d ", year);
//		}
//
//	}
//	return 0;
//
//}






//#include <stdio.h>
//int main()
//{
//	int i, a[10];
//	for (i = 0; i<=9; i++)   //对数组a[0]~a[9]赋值
//		a[i] = i;
//	for (i = 9; i>= 0; i--)  // 按顺序输出a[9]~a[0]十个元素
//		printf("%d",a[i]);
//	printf("\n");
//	return 0;

//}


//
//
//#include <stdio.h>					//冒泡排序
//int main()							
//{    
//	int a[10];
//	int i, j, t;
//	printf("input 10 number：\n");   
//	for (i = 0; i <= 10; i++)   // 给十个元素赋值
//		scanf("%d", &a[i]);
//	printf("\n");
//	for(j=0;j<9;j++)     // 总共要进行9次循环，实现9次比较
//		for(i=0;i<9-j;i++)   // 每一趟比较要进行9-j次比较
//			if (a[i] < a[i+1])   //相邻两个数的比较
//			{
//				t = a[i];
//				a[i] = a [i+1];
//				a[i+1] = t;
//			}
//	printf("the sorted number：\n");
//	for (i = 0; i < 10; i++)       //输出排序后的值
//		printf("%d ", a[i]);
//	printf("\n");
//	return 0;
//		}

//
//
//#include <stdio.h>
//int main()
//{
//	int i;
//	int a[5] = { 1,2,3,4,5 };
//	for (i = 0; i < 5; i++)
//		printf("%d ", a[i]);    //打印各个数组元素
//	return 0;
//
//}


//
//#include <stdio.h>
//int main()
//{
//	char x, y;
//	printf("请输入一个字母：");
//
//	x= getchar();
//	if (x >= 'A' && x <= 'Z')
//	{
//		y = x + 32;
//		printf("对应的小写字母为");
//		putchar(y);
//	}
//	else  
//		if(x >= 'a' && x <= 'z')
//			printf("对应的小写字母为：");
//		putchar(x);
//	printf("\n");
//	return 0;
//}
//
// 
// 
//#include <stdio.h>
//int main()
//{
//	int a = 10;
//
//	printf("a的长度为：%d\n", sizeof a);     //sizeof()不是个函数，括号可以省略
//	printf("a的长度为：%d\n", sizeof (int) );
//	
//	return 0;
//}

//
// 

// 
//#include <stdio.h>					//将一个二维数组行和列的元素互换，存放在另一个二维数组中
//int main()
//{
//	int a[2][3] = { {1,2,3},{4,5,6} };     //定义数组a的元素
//	int b[3][2],i,j;						//i j 分别为行和列
//	printf("数组a:\n");
//	for (i = 0; i <2; i++)				// 2 行
//	{
//		for (j = 0; j<3; j++)			// 3 列
//		{
//			printf("%6d", a[i][j]);     
//			b[j][i] = a[i][j];              //把a数组的行和列调换放进b数组里面
//
//		}
//		printf("\n");
//	}
//	printf("数组b：\n");
//	for (i = 0; i < 3; i++)              //3行
//	{
//		for (j = 0; j < 2; j++)         // 2列
//			printf("%6d", b[i][j]);        //打印调换后的b数组
//		printf("\n");
//	}
//	return 0;
//}



//
//#include <stdio.h>
//void test()
//{
//	int a = 1;
//	a++;
//	printf("%d ", a);                    //只需要打印值而不需要返回给原函数值的情况下用void （无返回值）
//}
//
//int main()
//{
//	int i = 0;
//	while (i < 10)
//	{
//		test();
//		i++;
//	}
//	return 0;
//}




//#include <stdio.h>
//int main()									//输出个菱形图
//{		
//	char diamond[][5] = { {' ',' ','*'},{' ','*',' ','*'},{'*',' ',' ',' ','*'},
//							{' ','*',' ','*'},{' ',' ','*'}};			         //字符数组	
//	int i, j;
//	for (i = 0; i < 5; i++)
//	{
//		for (j = 0; j < 5; j++)
//			printf("%c", diamond[i][j]);
//		printf("\n");
//	}
//	return 0;
//}



//
//#include <string.h>
//#include <stdio.h>
//int main()
//{
//	char a[9];
//	gets(a);
//	return 0;
//}







				//函数的嵌套：
				//定义函数时不能定义另一个函数，但是可以进行嵌套调用函数
				// 在A函数里调用B函数，以此类推
//			 //用函数嵌套求四个数的最大值
//#include<stdio.h>
//#include<stdlib.h>               //stdlib头文件是调用system() 是调用系统命令；pause 暂停命令；
//int max2(int a, int b)			//找出a和b中的最大值
//{
//	if (a >= b)
//	{
//		return a;			//	a作为返回值
//	}
//	return b;				//	b作为返回值
//}
//int max4(int a, int b, int c, int d)	//定义找4个数最大值的函数
//{
//	int m;		//存最大值
//	m = max2(a, b);		//调用max2函数，将a,b中大的值放在m中
//	m = max2(m, c);		//调用max2函数，将a,b，c中大的值放在m中
//	m = max2(m, d);		//调用max2函数，将a,b,c,d中大的值放在m中
//	return m;		//返回到主函数
//}
//int main()
//{
//	int a, b, c, d;
//	int max;
//	printf("请输入四个数：\n");
//	scanf("%d %d %d %d", &a, &b, &c, &d);
//	max = max4(a, b, c, d);			//调用max4函数
//	printf("最大数位：%d\n", max);
//	system("pause");			//system就是调用从程序中调用系统命令（和shell命令）
//							//就是在命令行上输出一行类似于“Press   any   key   to   exit”的字，等待用户按一个键，然后返回。
//	return 0;
//}


//
//#include <stdio.h>
//float cal(float x, float y)			//函数声明
//{ 
//	float z;
//	z = x + y;
//	return z;			//返回值z 给主函数
//
//}
//int main()
//{
//	float cal(float x, float y);	//函数声明
//	float a, b, c;
//	scanf("%f %f", &a, &b);
//	c = cal(a, b);				// 函数调用
//	printf("求和：%f", c);
//	return 0;
//
//}
//
//
// 
//#include <stdio.h>	//输入四个数，求他们之中的最大值
//int most(int a, int b, int c, int d);  //函数声明
//int main()
//{
//	int a, b, c, d, max;
//	printf("请输入四个数：\n");
//	scanf("%d %d %d %d", &a, &b, &c, &d);
//	max = most(a, b, c, d);
//	printf("%d", max);
//}
//int most(int a, int b, int c, int d)
//{
//	int mid(int x, int y);			 //函数嵌套
//	return mid(mid(mid(a, b), c), d); // 返回值可以是表达式
//}
//int mid(int x, int y)
//{
//	return x > y ? x : y;
//}



//
//#include <stdio.h>
//int main()
//{							//运用switch语句实现多分支选择语句
//	int life;
//	scanf("%d", &life);			
//	switch (life)			//括号内必须是表达式，其内容值的类型必须是整形（包括字符型，字符都用对应的ASCII码来储存）
//	{
//	case 1:					//case后跟整形常量表达式
//		printf("命运开端\n");
//	case 2:
//		printf("慢慢成长，懂得是非\n");
//	case 3:
//	case 4:
//	case 5:
//	case 6:
//		printf("明事理，懂生活，金钱和名誉的力量\n");
//		break;				//题目要求在哪里停止就在哪条case语句后面加break
//	default:				//在case语句完结后，都要加上个default语句用来表示超出case语句的内容
//		printf("此生终结\n");
//
//	}
//	return 0;
//}





//
//#include <stdio.h>
//int main()
//{
//	int m = 2, n = 1;
//	switch (n)
//	{
//	case 1:m++;
//	case 2:n++;
//	case 3:							//switch允许嵌套使用
//		switch (n)
//		{
//		case 1:n++;
//		case 2:m++; n++;
//			break;				//这个break只能跳出当前嵌套语句，
//								break是终止case分支语句。
//		}
//	case 4:
//		m++;
//		break;
//	default:
//		break;
//
//	}
//	printf("m=%d,n=%d\n", m, n);	// 得出结果m=5,n=3;
//	return 0;
//}

//
//#include <stdio.h>
//int main()
//{
//	int i = 1;
//	while (i <= 10)
//	{
//		if (5 == i)
//			break;		//break结束整体的循环。
//						//刚好i为5了就不进行后面的代码
//						//跳出整个i<=10循环
//		printf("%d ", i);//结果只能打印1，2，3，4
//		i++;
//	}
//	return 0;
//}


//
//#include <stdio.h>
//int main()
//{
//	int i = 1;
//	while (i <= 10)
//	{
//		i++;
//		if (5 == i)
//			continue;//结束本次循环，
//					//跳过continue后面的代码，
//					//直接转去循环判断部分，
//					//再判断是否继续下一次循环
//		printf("%d ", i);
//					//打印结果为：2到11，除了不打印5
//	}
//	return 0;
//}

//
//int main()
//{
//	int i, j, n = 0;
//	for(i=1;i<=4;i++)
//		for (j = 1; j <= 5; j++, n++)
//		{
//			if (n % 5 == 0)
//				printf("\n");
//			printf("%d\t",i*j);
//		}
//	return 0;
//}





//#define AP 3451525			//预处理指令、宏定义---> AP变量为符号常量
//												//符号常量不占用内存
//int main()
//{
//	double i = 168.2e-5;	//代表168.2乘以10的-5次方
//	printf("%lf\n", i);
//	float a = 55.55e-1;
//
//	printf("%f\n", a);
//	printf("%d\n", AP);		//输出AP所预处理命令定义的值
//	return 0;
//}



//
//int main()
//{											//让给出的数字找到对应的ASCII码
//	int arr[] = { 67,69,97,45,89,102,98 };		
//	int i = 0;
//	int sz = sizeof(arr) / sizeof(arr[0]);		//sizeof(arr) ：求整个数组的大小,单位是字节
//												//sizeof(arr[0]) ：数组元素的大小
//	for (i; i < sz; i++)
//	{
//		printf("%c", arr[i]);					//循环输出每个数字对应的ASCII码
//	}
//	return 0;
//}



//int main()
//{
//	int date = 0, month = 0, year = 0;
//	scanf("%4d %2d %2d", &year,& month,& date);  //格式控制字符：%4d代表读取四个整数
//	printf("year=%4d\n month-%02d\n date=%02d\n", year, month, date);
//	return 0;									//在打印时的格式控制字符：%2d 代表读取2位整数。
//}			
//		//而 %02d 代表也是读取两位整数，但如果输入的是一位数，会在打印时的第一位添0




//计算 1+2+3+...+n的值，n从键盘输入
//int main()
//{
//	int i = 0, n = 0, sum = 0;
//	scanf("%d", &n);
//	for (i = 1; i <= n; i++)
//	{
//		sum = sum + i;           //累加求和，用一个变量sum保存累加的结果
//	}
//	printf("sum=%d\n", sum);
//	return 0;
//}


//
//
//
////输出几年几月几日，判断这一天是这年中的第几天
//int main()
//{
//	int year, month, day;
//	int total = 0;
//	printf("请输入该年、月、日：\n");
//	scanf("%d %d %d", &year, &month, &day);
//	switch (month)
//	{
//	case 1:printf("1月份\n"); total = 0; break;
//	case 2:printf("2月份\n"); total = 31; break;
//	case 3:printf("3月份\n");
//		if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0)
//			total = 60;
//		else
//			total = 59;
//		break;
//	case 4:printf("4月份\n"); 
//		if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0)
//			total = 91;
//		else
//			total = 90;
//		break;
//	}
//	total = total + day;
//	printf("总天数为：%d\n", total);
//	return 0;
//}




//
////计算1！+2！+3！+...+n!的值，n从键盘输入
//int main()
//{
//	int i=1,n;
//	int ret = 1, sum = 0;
//	scanf("%d", &n);
//	for (i = 1; i <= n; i++)
//	{
//		ret = ret * i;
//		sum = sum + ret;
//	}
//	printf("ret=%d\n", ret);	//ret是计算n!的值
//	printf("sum=%d\n", sum);	//sum是1！+2！+...！的总和
//	return 0;
//}






//
//
////利用二分查找，在一个有序数组中查找某个数
//int main()
//{
//	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
//	int k = 7;
//	int sz = sizeof(arr) / sizeof(arr[0]);
//	int left = 0, right = sz - 1;
//	
//	while (left <= right)
//	{
//		//int mid = (left + right) / 2;				//此情况没考虑到溢出
//		int mid = left + (right - left) / 2;		//考虑溢出情况
//		if (arr[mid] < k)
//		{
//			left = mid + 1;
//		}
//			else if (arr[mid] > k)
//			{
//				right = mid - 1;
//
//			}
//				else
//				{
//					printf("找到了，\n下标是:%d\n",mid);
//					break;
//				}
//		
//	}
//	if (left > right)
//		printf("找不到所给值x\n");
//	return 0;
//}





//
//
////关机程序:
//#include <string.h>
//#include <windows.h>
//int main()
//{
//	char input[20] = { 0 };
//	system("shutdown -s -t 60");       //设置关机时间
//again:
//	printf("请输入：追寻属于心底里的爱。才能阻止关机\n");
//	printf("请输入:>");
//		scanf("%s", &input);
//		while (1)						//  死循环
//		{
//			if (strcmp(input, "追寻属于心底里的爱") == 0)
//			{
//                system("shutdown -a");   //取消关机
//                break;
//			}
//			else 
//			{
//				goto again;//跳转语句（不要常用，很容易出死循环）
//						//	 goto语句可以跳转到同一函数内的任意位置（不能跨函数）
//			}
//		}
//		return 0;
//}



//
//
////斐波那契数列,用迭代的方式实现
//int Fiber(int r)
//{
//	int a = 1, b = 1, c = 1;
//	while (r >= 3)
//	{
//        c = a + b;
//		a = b;
//        b = c;
//		r--;
//	}
//	return c;
//}
//
//int main()
//{
//	int r = 0;
//	printf("请输入一个斐波那契数字：");
//	scanf_s("%d", &r);
//	int ret = Fiber(r);
//    printf("%d\n", ret);
//	return 0;
//}





//将三个整数由大到小输出排序
//void get_max(int* love, int* like, int* miss)
//{
//	int temp = 0;
//	if (*love < *like)
//	{
//		temp = *love;
//        *love = *like;
//		*like = temp;
//	}
//	if (*love < *miss)
//	{
//        temp = *love;
//        *love = *miss;
//        *miss = temp;
//	}
//	if (*like < *miss)
//	{
//        temp = *like;
//		*like = *miss;
//        *miss = temp;
//	}
//}
//
//#include <stdio.h>
//int main()
//{
//	int a=0, b=0, c=0;
//
//	scanf("%d %d %d", &a, &b, &c);
//	get_max(&a,&b,&c);				//传址调用，函数调用是特殊的函数声明
//	printf("%d %d %d\n",a,b,c);
//	return 0;
//}






//
////求两数字的最大公约数 (辗转相除法)
//int main()
//{
//	int a = 0, b = 0;
//	scanf_s("%d %d", &a, &b);//输入两个数：18，24或者24，18 一个是除数，一个是被除数
//	int c = 0;	//  把余数赋值给c（让一个变量把余数储存起来）
//	while (c=a%b)//把a除以b的余数赋值给c
//	{
//		a = b;//把上一个b的值赋值给a
//		b = c;//把上一个余数赋值给b
//	}
//	printf("%d\n", b);//最后输出的b就是最大公约数
//	return 0;
//}




//
//
////计算1/1-1/2+1/3-1/4+...+1/99-1/100的值
//	//奇数为正，偶数为负
//	//分子为1，分母为i（1~100）
//int main()
//{
//	int i = 0;
//	int flag = 1;
//	double sum = 0;
//	for (i = 1; i <= 100; i++)
//	{
//		sum += flag*(1.0/i);
//		flag = -flag;
//
//	}
//	printf("sum=%lf\n", sum);
//	return 0;

//}


//
//
//
//int main()
//{
//	int arr[6] = { 0 };
//	int i = 0;
//	int sz = sizeof(arr) / sizeof(arr[0]);//计算数组大小
//	for (i = 0; i < sz; i++)
//	{
//		printf("%p\n", &arr[i]);  //%P打印地址 
//	}
//	return 0;
//}





//
////计算n的k次方（递归）
//double	Pow(double n, int k)
//{
//	if (k > 0)
//		return n * Pow(n, k - 1);
//	else if (k == 0)
//		return 1;
//    else
//		return 1.0/Pow(n, -k);
//}
//
//int main()
//{
//	double n = 0;
//	int k = 0;
//    scanf_s("%lf %d", &n, &k);
//	double ret = Pow(n, k);
//	printf("%lf\n", ret);
//}


//
////用递归实现斐波那契数列
//int Fiber(int r)
//{
//	if (r == 1 || r == 2)
//		return 1;
//	else
//		return Fiber(r - 1) + Fiber(r - 2);
//}
//
//
//int main()
//{
//    	int r = 0;
//        	printf("请输入一个斐波那契数字：");
//        	scanf_s("%d", &r);
//        	int ret = Fiber(r);
//        	printf("%d\n", ret);
//}



//
////两个数组里面元素互相交换
//int main()
//{
//	int arr1[] = { 1,3,5,7,9 };
//	int arr2[] = { 2,4,6,8,0 };
//	int seed = sizeof(arr1) / sizeof(arr1[0]);
//	int i = 0;
//	for (i = 0; i < seed; i++)
//	{
//		
//		int tempt = arr1[i];
//		arr1[i] = arr2[i];
//		arr2[i] = tempt;
//	}
//	for (i = 0; i < seed; i++)
//	{
//		printf("arr1=%d ", arr1[i]);
//	}
//	printf("\n");
//	for (i = 0; i < seed; i++)
//	{
//		printf("arr2=%d ", arr2[i]);
//	}
//	printf("\n");
//	return 0;
//}






//
////求出一个整数在内存中存储时，二进制中1的个数
//
//int main()
//{
//	int num = 0;
//    scanf_s("%d", &num);
//	int i;
//	int count = 0;
//	for (i = 1; i <=32; i++)
//	{
//		if(((num >> i) & 1) == 1)
//			count++;
//	}
//	printf("%d\n", count);
//	return 0;
//
//}




//
//int main()
//{
//	int* p = NULL;
//	char* p1 = NULL;
//	double* p2 = NULL;
//	float* p3 = NULL;
//	short* p4 = NULL;
//	printf("%zu\n", sizeof(p));
//    printf("%zu\n", sizeof(p1));
//    printf("%zu\n", sizeof(p2));
//    printf("%zu\n", sizeof(p3));
//	printf("%zu\n", sizeof(p4));
//     return 0;
//}

//int main()
//{
//	int arr[8] = { 0 };
//	int i = 0;
//	int* p = arr;
//	for (i = 0; i < 8; i++)
//	{
//	//	 *p = 1;   // 等价下面的表达式
//	//	 p++;
//		*(p + i) = 1;
//
//	}
//	for(i=0;i<8;i++)
//	printf("%d ", arr[i]);
//	return 0;
//}
//




//
//int main()
//{
//	int flag = 1;
//	int i = 1;
//	double sum = 0;
//	for (i = 1; i <= 100; i++)
//	{
//		sum += flag*(1.0 / i);
//		flag = -flag;
//
//	}
//	printf("%lf\n", sum);
//	return 0;
//}




//
////sizeof用法
////和各种类型所占空间大小
//int main()
//{
//	int a = 0;
//	printf("%d\n", sizeof (a));
//	printf("%d\n", sizeof (int));
//	printf("%d\n", sizeof (char));
//	printf("%d\n", sizeof (short));
//	printf("%d\n", sizeof (long));
//	printf("%d\n", sizeof (float));
//	printf("%d\n", sizeof (long long));
//	printf("%d\n", sizeof (double));
//
//
//	return 0;
//}


//
////实现两个数组元素交换
//void swap_elements(int arr1[], int arr2[], int size) {
//    for (int i = 0; i < size; i++) {
//        int temp = arr1[i];
//        arr1[i] = arr2[i];
//        arr2[i] = temp;
//    }
//}
//
//int main() {
//    int arr1[] = { 1, 2, 3, 4, 5 };
//    int arr2[] = { 6, 7, 8, 9, 10 };
//    int size = sizeof(arr1) / sizeof(arr1[0]);
//
//    printf("Before swap: \n");
//    for (int i = 0; i < size; i++) {
//        printf("%d ", arr1[i]);
//    }
//    printf("\n");
//    for (int i = 0; i < size; i++) {
//        printf("%d ", arr2[i]);
//    }
//    printf("\n");
//
//    swap_elements(arr1, arr2, size);
//
//    printf("After swap: \n");
//    for (int i = 0; i < size; i++) {
//        printf("%d ", arr1[i]);
//    }
//    printf("\n");
//    for (int i = 0; i < size; i++) {
//        printf("%d ", arr2[i]);
//    }
//    printf("\n");
//
//    return 0;
//}




// int main()
// {
// 	char arr[] = { 'a','b','c' };
// 	printf("%s", arr);


// }








//字符A~Z的ASCII码值从65~90
//字符a~z的ASCII码值从97~122
////将小写字母转换成大写字母
//int main()
//{
//    char a,b;
//    scanf("%c %c",&a,&b);
//    if(a>=97&&a<=122)
//    {
//        a=a-32;
//    }
//    if(b>=97&&b<=122)
//    {
//        b=b-32;
//    }
//    printf("%c %c",a,b);
//	return 0;
//}
//
//
// 
// 
//#include <string.h>
////字符串长度、转义字符
//int main()
//{
//	char a[] = { "c:\test\net\able\big\126" };//字符串默认有'\0'
//	int  d= strlen(a);//心想是17
//	int e= sizeof(a);//心想是18
//	printf("%d\n", d);
//	printf("%d\n", e);
//	return 0;
//}


//
//
//#include <stdio.h>
//int main()
//{
//	int a = 0, b = 0;
//	for (a = 1, b = 1; a <= 100; a++)
//	{
//		if (b >= 20) break;
//		if (b % 3 == 1)
//		{
//			b = b + 3;
//			continue;
//		}
//		b = b - 5;
//	}
//	printf("%d\n", a);
//	return 0;
//}


//
////二分查找，折半查找
//int main()
//{
//	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
//	int k = 0;
//	printf("请输入你要查找的数：\n");
//	scanf("%d", &k);
//	int sz = sizeof(arr) / sizeof(arr[0]);//数组元素个数
//	int left = 0;
//	int right = sz - 1;
//	
//
//	while (left <= right)
//	{
//		int mid = left + (right - left) / 2;//中间下标
//		if (arr[mid] < k)
//		{
//			left = mid + 1;
//		}
//		else if (arr[mid] > k)
//		{
//
//			right = mid - 1;
//		}
//		else
//		{
//			printf("找到了，下标是%d\n", mid);
//			break;
//		}
//
//
//
//	}
//	if (left > right)
//	{
//		printf("找不到此数\n");
//
//	}
//
//
//	return 0;
//
//}
//
//

//
////输入某年某月，计算这个月的天数
//int is_leap_year(int y)
//{
//	if ((y % 4 == 0) && (y % 100 != 0) || (y % 400 == 0))
//	{
//		return 1;
//
//	}
//	else
//		return 0;
//}
//
//int get_days_of_month(int y, int m)
//{
//	int days[] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };//平年
//	int day =days[m];
//	if (is_leap_year(y) && m == 2)
//	{
//		return day += 1;
//	}
//	else
//		return day;
//
//}
//
//
//int main()
//{
//	int year = 0;
//	int month = 0;
//	scanf("%d %d", &year, &month);
//	int day = get_days_of_month(year, month);
//	printf("这个月有%d天\n", day);
//	return 0;
//}

//
//
//int main()
//{
//	int i = 0;
//	int arr[20] = {0};
//	for (i = 0; i < 20; i++)
//	{
//		if (i >= 2 && i < 20) 
//		{
//			arr[i] = arr[i - 1] + arr[i - 2];
//			
//		}
//		else {
//			arr[i] = 1;
//		}
//          
//		printf("%d ", arr[i]);
//	
//	}
//
//
//	return 0;
//}
// 
// 
// 
// 







////多个字符从两端移动，向中间汇聚
////编写代码，多个字符从两端移动，向中间汇聚
//#include <string.h>
//#include <windows.h>
//int main()
//{
//	char arr1[] = "welcome to bit...";//18
//	char arr2[] = "#################";//18
//	int left = 0;
//	int right = (int)strlen(arr1) - 1;
//	printf("%s\n", arr2);
//	while (left <= right)
//	{
//		Sleep(1000);//停顿1秒
//		arr2[left] = arr1[left];
//		arr2[right] = arr1[right];
//		left++;
//		right--;
//		printf("%s\n", arr2);
//	}
//	return 0;
//}


////九九乘法表
//int main()
//{
//	int i = 0, j = 0;
//	for (i = 1; i <= 9; i++)//循环遍历行
//	{
//		for (j = 1; j <= i; j++)
//		{
//            printf("%d*%d=%d\t", j, i, i * j);
//		}
//        printf("\n");
//	}
//
//
//	return 0;
//}

//
////打印100~200之间的素数
////思路：先产出100~200的数字，然后判断这个数字是不是素数，是素数就打印出来
////用产生出来的数字，去除2~sqrt(这个数字)之间的数字，如果都没有被整除，那么这个数字就是素数
//#include <math.h>
//int main()
//{
//	int i = 0;
//	for (i = 101; i <= 200; i+=3)//素数都是奇数，所以步长为3,可以忽略100
//	{
//        int j = 0;
//		for (j = 2; j <= sqrt(i); j++)//减少循环次数，用sqrt(i)代替i，直接把i开方缩短时间
//		{
//			if (i % j == 0)//不是素数的判断
//			{
//				break;//跳出内层for循环
//			}
//		}
//		if (j > sqrt(i))
//		{
//            printf("%-5d", i);//打印素数
//		}
//
//	}
//	return 0;
//}
//

//
////程序输出的结果是：
//int main()
//{
//	int a = 0, b = 0;
//	for (a = 1, b = 1; a <= 100; a++)
//	{
//		if (b >= 20) break;
//		if (b % 3 == 1)
//		{
//			b = b + 3;
//			continue;//跳出本次for循环，继续下一次循环
//		}
//		b = b - 5;
//	}
//	printf("%d\n", a);//总共循环8次，a=8
//	return 0;
//}




//
////求10 个整数中最大值
//int main()
//{
//	 int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
//	 int i = 0;
//	 int max = arr[0];//打擂台算法
//	 for (i = 0; i < 10; i++)
//	 {
//		 
//		 if (arr[i] > max)
//		 {
//			 max = arr[i];
//
//		 }
//	 }
//	 printf("最大值是%d\n", max);
//	return 0;
//}







//
//
////分数求和
////计算1 / 1 - 1 / 2 + 1 / 3 - 1 / 4 + 1 / 5 …… + 1 / 99 - 1 / 100 的值，打印出结果
//int main()
//{
//	//把分数的分子和分母分开
//	//由繁化简：1-2+3-4+...+99-100（偶数为负数）
//	//1+2+3+4+...+99+100(可以先算这个然后再往上推)
//	 double num = 0.0; // 总和
//	int i = 0;
//	int flag = 1;//把偶数变成负数，符号位标记
//	for (i = 1; i <= 100; i++)
//	{
//        num += flag * (1.0 / i);//1.0强制转换成浮点数
//        flag = -flag;//符号位取反
//		
//	}
//    	printf("分数求和的结果为%lf\n", num);
//	return 0;
//}


//
////编写程序数一下 1到 100 的所有整数中出现多少个数字9
//int main()
//{
//	int i = 0;//初始化i
//	//先产生1到100的数字
//    int count = 0;//记录9的个数
//	for (i = 1; i <= 100; i++)
//	{
//		if (i % 10 == 9)//个位为9
//		{
//            count++;
//		}
//		if (i / 10 == 9)//十位为9
//		{
//            count++;
//		}
//	}
//	printf("1到100的数字中9出现的次数为%d\n", count);
//
//	return 0;
//}
//
//



//
//
////给定两个数，求这两个数的最大公约数
////利用辗转相除法求解
////算法思路：被除数赋值给a，除数赋值给b，余数赋值给c
//// 把b赋值给a，把余数赋值给b，然后继续求a除以b的余数，直到余数为0，此时b就是最大公约数
//int main()
//{
//	int a=0, b=0;
//	printf("请输入被除数与除数:\n");
//	scanf("%d %d", &a, &b);
//	int c = 0;
//	while (c = a % b)
//	{
//		a = b;
//		b = c;
//	}
//	printf("最大公约数为%d\n", b);
//	return 0;
//}


//
//
////打印1000年到2000年之间的闰年
//int is_leap_year(int year)
//{
//	if ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0))
//	{
//		return 1;
//	}
//	return 0;
//}
//
//
//int main()
//{
//	int i = 0;
//	for (i = 1000; i <= 2000; i++)
//	{
//		if (is_leap_year(i) == 1)
//		{
//            printf("是闰年的有：%d\t", i);
//		}
//	}
//
//	return 0;
//}


//输入描述：
//多组输入，一个整数（2~20），表示输出的行数，也表示组成“X”的反斜线和正斜线的长度。
//输出描述：
//针对每行输入，输出用“ * ”组成的X形图案
//
//int main()
//{
//	int n = 0;
//	scanf("%d", &n);
//	int i, j;
//	for (i = 1; i <= n; i++)//行
//	{
//		for (j = 1; j <= n; j++)
//		{
//			if (i == j || i + j == n + 1)//   i==j为了控制左斜线，i+j==n+1为了控制右斜线
//			{
//				printf("*");
//			}
//			else
//				printf(" ");
//		}
//		printf("\n");
//		
//	}
//
//
//	return 0;
//}

//
////求1！+2！+3！+...+10！的和
//int main()
//{
//	int a = 1;
//	int ret = 1;//求n的阶乘表示值
//	int sum = 0;//求阶乘的和
//	for (a = 1; a <= 10; a++)
//	{
//		ret *= a;//求n的阶乘
//		sum += ret;//累加
//	}
//	printf("%d\n", sum);//输出结果累加和
//
//
//	return 0;
//}






//
//
////	输入描述：
////多组输入，一个整数（3~20），表示输出的行数，也表示组成正方形边的“ * ”的数量。
////	输出描述：
////针对每行输入，输出用“* ”组成的“空心”正方形，每个“* ”后面有一个空格。
//void print(int n)
//{
//	int i = 0, j = 0;
//		for (i = 0; i < n; i++)
//		{
//			for (j = 0; j < n; j++)
//			{
//				if (i!=0 && i!=n-1 && j!=0 && j!=n-1)
//				{
//					printf("  ");
//				}	
//				else
//				{
//					printf("* ");
//				}
//			}
//			printf("\n");
//		}
//}
//int main()
//{
//	int n = 0;
//	
//	while (scanf("%d", &n) != EOF)
//	{
//		print(n);
//	}
//	return 0;
//}




//【二维数组】 - 矩阵转置
//输入描述：
//第一行包含两个整数n和m，表示一个矩阵包含n行m列，用空格分隔。(1≤n≤10, 1≤m≤10)
//
//从2到n + 1行，每行输入m个整数（范围 - 231~231 - 1），用空格分隔，共输入n * m个数，表示第一个矩阵中的元素。
//
//输出描述：
//输出m行n列，为矩阵转置后的结果。每个数后面有一个空格
//int main()
//{
//	int m = 0, n = 0;
//	int arr[10][10] = { 0 };
//	scanf("%d %d", &m, &n);
//	int i = 0, j = 0;
//	for (i = 0; i < m; i++)
//	{
//		for (j = 0; j < n; j++)
//		{
//			scanf("%d", &arr[i][j]);
//		}
//	}
//	for (i = 0; i < n; i++)
//	{
//		for (j = 0; j < m; j++)
//		{
//			printf("%d ", arr[j][i]);
//		}
//		printf("\n");
//	}
//
//	return 0;
//}




//
////
////
////	输入10个整数，要求按输入时的逆序把这10个数打印出来。逆序输出，就是按照输入相反的顺序打印这10个数。
////输入描述：
////	一行，输入10个整数（范围 - 231~231 - 1），用空格分隔。
////输出描述：
////	一行，逆序输出输入的10个整数，用空格分隔。
////
////
//int main()
//{
//	int arr[10] = { 0 };
//	int i = 0;
//	int sz = sizeof(arr) / sizeof(arr[0]);
//	for (i = 0; i < 10; i++)//10次
//	{
//		scanf("%d", &arr[i]);
//
//	}
//	for (i = sz - 1; i >= 0; i--)//逆序输出
//	{
//		printf("%d ", arr[i]);
//	}
//
//	return 0;
//}



////【无符号整数】 - 输出无符号整数
//int main() {
//	unsigned int num = 4294967295U; // 这是一个无符号整数的例子，值为2^32 - 1  
//	printf("The number is: %u\n", num);
//	return 0;
//}



//
////【十六进制和八进制】 - 输出十六进制和八进制
//
//int main() {
//	unsigned int num = 4294967295U; // 2^32 - 1  
//	printf("The number in hexadecimal is: %x\n", num); // 输出：ffffffff  
//	printf("The number in hexadecimal (uppercase) is: %X\n", num); // 输出：FFFFFFFF  
//	printf("The number in octal is: %o\n", num); // 输出：37777777777  
//	return 0;
//}

//int main()
//{
//	float a = 3.146f;
//	printf("%.2f\n", a);
//	return 0;
//}


//
//int main()
//{
//	size_t a = 0;//size_t是无符号整数类型，表示数据大小
//	printf("%zd\n",sizeof(a));
//
//
//	return 0;
//}



//
////数组名是一个指向数组首元素的指针，但是它指向的是整个数组，而不是单个元素。
////因此，&arr和arr的值是相同的，都是数组首元素的地址。但是，&arr表示的是整个数组的地址，
//// 而arr表示的是数组首元素的地址。
//int main()
//{
//	int arr[10] = { 0 };
//	int* p = arr;
//	printf("&arr[0]=%p\n", &arr[0]);//等价于p
//	printf("p      =%p\n", p);
//	printf("arr    =%p\n", arr);
//	printf("&arr   =%p\n", &arr);//此处arr代表数组首元素的地址，&arr代表整个数组的地址
//	printf("\n");
//	printf("\n");
//	printf("&arr[0]+1=%p\n", &arr[0]+1);//等价于p+1
//	printf("arr+1    =%p\n", arr+1);
//	printf("&arr+1   =%p\n", &arr+1);//+1代表跳过整个数组，即跳过40个字节
//	return 0;
//	//但有两个例外：
//	//sizeof(arr)返回整个数组的大小，而不是数组首元素的地址。
//	//&arr返回整个数组的地址，而不是数组首元素的地址。
//}
//




//练习题：有序序列合并
// 
//描述：
//输入两个升序排列的序列，将两个序列合并为一个有序序列并输出
// 
//输入描述：
//输入包含三行，
//第一行包含两个正整数n, m，用空格分隔。n表示第二行第一个升序序列中数字的个数，m表示第三行第二个升序序列中数字的个数。
//
//第二行包含n个整数，用空格分隔。
//
//第三行包含m个整数，用空格分隔
//输出描述：
//输出为一行，输出长度为n + m的升序序列
//即长度为n的升序序列和长度为m的升序序列中的元素重新进行升序序列排列合并。

//
//
//int main()
//{
//    int n, m;
//    scanf("%d %d\n", &n, &m);
//    int i, j, arr[2000] = {0};
//    int tmp;
//    for (i = 0; i < n; i++)
//    {
//        scanf("%d ", &arr[i]);
//    }
//    for (i = n; i < n + m; i++)
//    {
//        scanf("%d ", &arr[i]);
//    }
//    for (i = 0; i < n + m; i++)
//    {
//        for (j = 0; j < n + m - i - 1; j++)
//        {
//            if (arr[j] > arr[j + 1])
//            {
//                tmp = arr[j];
//                arr[j] = arr[j + 1];
//                arr[j + 1] = tmp;
//            }
//        }
//    }
//    for (i = 0; i < n + m; i++)
//    {
//        printf("%d ", arr[i]);
//    }
//}


//
////编写一个程序，从用户输入中读取10个整数并存储在一个数组中。
//// 然后，计算并输出这些整数的平均值
//int main()
//{
//	int arr[10] = { 0 };
//	int i = 0;
//	int sum = 0;
//    printf("请输入10个整数：\n");
//	for (i = 0; i < 10; i++)
//	{
//		scanf("%d", arr+i);
//	}
//	int j = 0;
//	for (j = 0; j < 10; j++)
//	{
//		sum += arr[j];
//	}
//	 double avg= sum / 10.0;
//	printf("avg=%lf\n ", avg);
//		
//
//	
//
//
//	return 0;
//}





//【一维数组】交换数组
//将数组A中的内容和数组B中的内容进行交换。（数组一样大）
//int main()
//{
//	int arrA[] = { 1,2,3 };
//	int arrB[] = { 4,5,6 };
//	printf("交换前：\n");
//	for (int i = 0; i < 3; i++)
//	{
//        printf("%d ", arrA[i]);
//	}
//    printf("\n");
//	for (int i = 0; i < 3; i++)
//	{
//        printf("%d ", arrB[i]);
//	}
//    printf("\n");
//	for (int i = 0; i < 3; i++)
//	{
//		int tmp=arrA[i];
//		arrA[i] = arrB[i];
//        arrB[i] = tmp;
//	}
//    printf("交换后：\n");
//	for (int i = 0; i < 3; i++)
//	{
//		printf("%d ", arrA[i]);
//	}
//    printf("\n");
//	for (int i = 0; i < 3; i++)
//	{
//       printf("%d ", arrB[i]);
//	}
//
//
//	return 0;
//}
//
////优化：
//void Swap(int* arrA, int* arrB, int n)
//{
//	for (int i = 0; i < n; i++)
//	{
//    int tmp = arrA[i];
//    arrA[i] = arrB[i];
//    arrB[i] = tmp;
//
//	}
//}
//void print_arr(int* arr, int n)
//{
//	for (int i = 0; i < n; i++)
//	{
//		printf("%d ", arr[i]);
//	}
//	printf("\n");
//}
//int main()
//{
//	int arrA[] = { 1,2,3 };
//	int arrB[] = { 4,5,6 };
//	printf("交换前：\n");
//	print_arr(arrA, 3);
//	print_arr(arrB, 3);
//	Swap(arrA, arrB, 3);
//	printf("交换后：\n");
//	print_arr(arrA, 3);
//	print_arr(arrB, 3);
//	return 0;
//}


//
//// 
////写一个二分查找函数
////
////功能：在一个升序数组中查找指定的数值，找到了就返回下标，找不到就返回 - 1.
//int bin_search(int* arr, int left, int right, int key)
//{
//
//	while (left <= right)
//	{
//		int mid = (left + right) / 2;//中间下标
//		if (arr[mid] < key)
//		{
//			left = mid + 1;
//
//		}
//		else if (arr[mid] > key)
//		{
//			right = mid - 1;
//		}
//		else
//		{
//			return mid;
//		}
//	}
//	return -1;
//}
//
//int main()
//{
//	int arr[] = {1,2,3,4,5,6,7,8,9,10};
//	int key = 0;
//	scanf("%d", &key);
//	int sz = sizeof(arr) / sizeof(arr[0]);
//	int left = 0;//左下标
//	int right = sz - 1;//右下标
//
//	int num=bin_search(arr, left, right,key);
//	if (num == -1)
//	{
//        printf("找不到\n");
//	}
//    else
//	{
//       printf("找到了，下标为%d\n", num);
//	}
//
//	return 0;
//}


//
////
////实现一个函数，打印乘法口诀表，口诀表的行数和列数自己指定
////
////如：输入9，输出9 * 9口诀表，输出12，输出12 * 12的乘法口诀表。
//void multiple(int n)
//{
//	int i = 0;
//	for (i = 1; i <= n; i++)
//	{
//       int j = 0;
//	   for (j = 1; j <= i; j++)
//	   {
//		   printf("%d*%d=%-2d ", j,i, i * j);
//	   }
//       printf("\n");
//	}
//}
//int main()
//{
//	int n = 0;
//	scanf("%d", &n);
//	multiple(n);
//	return 0;
//}


//
////实现函数判断year是不是闰年。
//void is_leap_year(int year)
//{
//	while (year)
//	{
//		if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0)
//		{
//			printf("%d是闰年\n", year);
//			break;
//		}
//		else
//		{
//			printf("%d不是闰年\n", year);
//			break;
//		}
//	}
//	
//}
//int main()
//{
//	int year = 0;
//	scanf("%d", &year);
//	is_leap_year(year);
//
//	return 0;
//}



//
////实现一个函数is_prime，判断一个数是不是素数。
////
////利用上面实现的is_prime函数，打印100到200之间的素数。
//#include <math.h>
//void is_prime(int n)
//{
//	for (int i = 2; i <= sqrt(n); i++)
//	{
//		if (n % i == 0)
//		{
//			return;//不是素数,直接返回后面printf不会执行
//                        		
//		}
//	}
//    printf("%d\n", n);//是素数
//
//}
//int main()
//{
//	int i = 0;
//	for (i = 100; i <= 200; i++)
//	{
//		is_prime(i);
//	}
//	return 0;
//}



//
////创建一个整形数组，完成对数组的操作
////
////实现函数init() 初始化数组为全0
////实现print()  打印数组的每个元素
////实现reverse()  函数完成数组元素的逆置。
////要求：自己设计以上函数的参数，返回值。
//void init_arr(int* arr, int sz)
//{
//	int i = 0;
//	for (i = 0; i < sz; i++)
//	{
//		printf("%d ", *(arr+i)=0);
//	}
//}
//void print_arr(int* arr, int sz)
//{
//	int i = 0;
//	for (i = 0; i < sz; i++)
//	{
//		printf("%d ", *(arr+i));
//	}
//	printf("\n");
//}
//void reverse_arr(int* arr, int sz)
//{
//	int i = 0;
//	int left = 0;
//	int right = sz - 1;
//	while (left < right)
//	{
//		int tmp = arr[left];
//        arr[left]= arr[right];
//        arr[right] =tmp;
//		left++;
//		right--;
//	}
//	print_arr(arr, sz);
//}
//int main()
//{
//	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
//	int sz = sizeof(arr) / sizeof(arr[0]);
//	print_arr(arr, sz);
//	reverse_arr(arr, sz);
//	init_arr(arr,sz);
//	
//	return 0;
//}


//
////初识数组指针
//int main()
//{
//	//第一种：
//	//int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
//	//int* p= arr;//指针变量p指向数组arr的首元素
//	//for (int i = 0; i < 10; i++)
//	//{
//	//	printf("%d ", p[i]);//p[i] == *(p+i)== *(arr+i)== arr[i]
//	//}
//
//	//第二种：
//	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
//	int(*p)[10]= &arr;//数组指针,指向整个数组
//	int i = 0;
//	for (i = 0; i < 10; i++)
//	{
//		printf("%d ", (*p)[i]);//(*p)[i] == *(p+i) == arr[i]
//	}
//
//
//
//	return 0;
//}
//
////二维数组传参
//void Print(int(*p)[5], int row, int col)
//{
//	int i = 0;
//	for (i = 0; i < row; i++)
//	{
//		int j = 0;
//		for (j = 0; j < col; j++)
//		{
//			//-2d表示左对齐，2表示占位2个字符（对齐数）
//			printf("%-2d ", *(*(p + i)+j));//*(p + i) == p[i]拿到的是第i行的地址
//			//p[i]表示的是第i行的数组名，由于数组名是首元素地址，所以p[i]=&arr[i][0]
//			// +j表示第i行的第j个元素的地址
//			//*(*(p + i) + j)表示第i行的第j个元素的值
//		}
//		printf("\n");
//	}
//}
//int main()
//{
//	int arr[3][5] = { {1,2,3,4,5},{6,7,8,9,10},{11,12,13,14,15} };
//	Print(arr, 3, 5);//arr是表示二维数组第一行的地址
//	return 0;
//}



//
//int main()
//{
//	char* a[] = { "work","at","alibaba" };//字符串存储的是首字母的地址，所以a[]存储的是字符串首字母的地址
//	char** pa = a;//pa存储的是字符串首字母的地址
//	for (int i = 0; i < 3; i++) {
//
//		printf("%s\n", *pa);
//		pa++;
//	}
//
//
//	return 0;
//}

//
//
////明确指针指向
//int main()
//{
//	char* c[] = { "ENTER", "NEW", "POINT", "FIRST" };
//	char** cp[] = { c + 3,c + 2,c + 1,c };
//	char*** cpp = cp;
//	printf("%s\n", **++cpp);
//	printf("%s\n", * -- * ++cpp + 3);
//    printf("%s\n", * cpp[-2] + 3);
//    printf("%s\n", cpp[-1][-1] + 1);
//
//	return 0;
//}


//
////给出一个字符串，将其中的小写字母转换成大写字母
//#include <ctype.h>
//int main()
//{
//	char arr[] = { "I am a Student."};
//	int i = 0;
//	while (arr[i++] != '\0')
//	{
//		if (islower(arr[i]))
//		{
//			arr[i]-= 32;
//		}
//
//	}
//	printf("%s\n", arr);
//
//	return 0;
//}
//
////使用strcpy函数  and strlen函数
//#include <string.h>
//int main()
//{
//	char arr1[] = "I love you";
//	char arr2[20] = { 0 };
//	strcpy(arr2, arr1);//将arr1中的字符串拷贝到arr2中
//	size_t p=strlen(arr2);//不包含'\0'的字符个数
//	printf("%s\n", arr2);
//	printf("%zd\n", p);
//	return 0;
//}

//
//#include <stdio.h>
//int main()
//{
//	int i = 0;
//	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
//	for (i = 0; i <= 12; i++)
//	{
//		arr[i] = 0;
//		printf("hello bit\n");
//	}
//	return 0;
//}

//
////喝汽水问题
////喝汽水，1瓶汽水1元，2个空瓶可以换一瓶汽水，给20元，可以喝多少汽水（编程实现）。
//int main()
//{
//    int money = 20;
//	int buttle = 0;
//    int sum_buttle = 0;//总瓶数
//    sum_buttle = money;
//	buttle = money; 
//	while (buttle >= 2)
//	{
//		sum_buttle += buttle / 2;//总瓶数加上空瓶换的汽水
//		buttle = buttle / 2 + buttle % 2;//空瓶数加上剩余的空瓶
//	}
//	printf("总瓶数为%d\n", sum_buttle);
//	return 0;
//}

//
////模拟实现strcmp：如果相等返回0，如果目标字符串大返回正数，如果源字符串大返回负数
//int my_strcmp(const char* str1, const char* str2)
//{
//	while (*str1 == *str2)//先比较字符
//	{
//		if (*str1 == '\0')
//		{
//			return 0;
//		}
//		str1++;
//		str2++;
//	}
//	return (*str1 - *str2);
//}
//int main()
//{
//	char arr1[] = "abcdef";
//	char arr2[] = "abq";
//	int ret = my_strcmp(arr1, arr2);
//	printf("%d\n", ret);
//	return 0;
//}


//
////打印三角形
//int main()
//{
//	int i = 0, j = 0;
//	for (i = 0; i < 6; i++)//循环6次
//	{
//		for (j = 0; j < 6 - i; j++)
//		{
//            printf(" ");
//		}
//		for (j = 0; j < 2 * i + 1; j++)
//		{
//            printf("*");
//		}
//        printf("\n");
//	}
//	for (i = 0; i < 7; i++)
//	{
//		for (j = 0; j < i; j++)
//		{
//            printf(" ");
//		}
//		for (j = 0; j < 2 * (6 - i) + 1; j++)
//		{
//            printf("*");
//		}
//        printf("\n");
//	}
//	return 0;
//}



////求1-100000之间的水仙花数
//#include <math.h>
//int main()
//{
//	//先产生1-100000的数字
//	for (int i = 0; i <= 100000; i++)
//	{
//		//把每个数字的每一位取出来
//		int ge = i % 10;
//		int shi=i / 10 % 10;
//        int bai = i / 100 % 10;
//		if (i == pow(ge, 3) + pow(shi, 3) + pow(bai, 3))//判断是否为水仙花数
//		{
//            printf("水仙花数字:%d\n", i);
//		}
//	}
//    
//
//	return 0;
//}



//
//
//#include <stdio.h>
//
//int main() {
//	int a, i, term = 0, sum = 0;
//
//	printf("请输入一个数字a: ");
//	scanf("%d", &a);
//
//	for (i = 1; i <= 5; i++) {
//		term = term * 10 + a; // 构建当前项，比如a, aa, aaa...
//		sum += term; // 累加到总和中
//	}
//
//	printf("前5项之和是: %d\n", sum);
//
//	return 0;
//}
//


//
////函数栈帧
//int Add(int x, int y)
//{
//	int z = x + y;
//    return z;
//}
//
//int main()
//{
//	int a = 20;
//	int b = 10;
//	int c = Add(a, b);
//	printf("%d\n", c);
//	return 0;
//}




////使用不创建第三个变量，交换两个变量的值
//int main()
//{
//	int a = 10;
//	int b = 20;
//	printf("交换前:a=%d b=%d\n", a, b);
//	a = a ^ b;
//	b = a ^ b;//b=a^b^b --> b=a^0 --> b=a
//    a = a ^ b;//a=a^b^a --> a=0^b --> a=b
//	printf("交换后:a=%d b=%d\n", a, b);
//	return 0;
//}



////求任意整数的二进制位 1的个数
////方法一：数学角度：
//int count_binary(unsigned int num)
//{
//	int count = 0;
//	while (num)
//	{
//		if (num % 2 == 1)
//		{
//			count++;
//		}
//        num /= 2;
//	}
//	return count;
//}

//int main()
//{
//    int num = 0;
//    scanf("%d", &num);
//	int ret = count_binary(num);
//    printf("%d\n", ret);
//	return 0;
//}
// 
////方法二：位运算角度：(无需考虑传参的正负性)
//int count_num_binary(int num)
//{
//	int i = 0;
//	int count = 0;
//	for (i = 0; i < 32; i++)
//	{
//		if ((num >> 1) & 1 == 1)
//		{
//            count++;
//		}
//	}
//    return count;
//}
//int main()
//{
//	int num = 0;
//	scanf("%d", &num);
//	int ret = count_num_binary(num);
//	printf("%d\n", ret);
//	return 0;
//}



////判断n是否是2的整数次方
//int main()
//{
//	  int num = 0;
//	  scanf("%d", &num);
//    if ((num & (num - 1)) == 0)
//    {
//        printf("是2的整数次方\n");
//    }
//	  else
//	 {
//        printf("不是2的整数次方\n");
//	 }
//	return 0;
//}


//
////echo.c程序，测试I/O缓冲区
//int main()
//{
//	char ch;
//	while ((ch = getchar()) != EOF)//EOF表示文件结束符，当输入ctrl+z时，才能使程序停止
//	{
//		putchar(ch);
//	}
//	return 0;
//}


//int main()
//{
//	int f1 = 1;
//	int f2 = 1;
//	int f3 = 1;
//	int n = 0;
//	printf("请输入想求第N项的斐波那契数:");
//	scanf("%d", &n);
//
//	for (int i = 2; i < n; i++)
//	{
//		f3 = f1 + f2;
//        f1 = f2;
//        f2 = f3;
//	
//	}
//	printf("\n第%d项的斐波那契数列的值为：%d\n", n, f3);
//
// 
// 
//
//	return 0;
//}




//int Fibonacci(int n)
//{
//	if (n == 1 || n == 2)
//	{
//		return 1;
//	}
//	else {
//		return Fibonacci(n - 1) + Fibonacci(n - 2);
//	}
//	
//}
//int main()
//{
//	int n = 0;
//	int ret = 0;
//	printf("请输入想求第N项的斐波那契数:");
//	scanf("%d", &n);
//	for (int i = 0; i < n; i++)
//	{
//		ret = Fibonacci(n);
//	}
//	printf("\n第%d项的斐波那契数列的值为：%d\n", n, ret);
//
//	return 0;
//}



////实现结构体嵌套并打印
//struct P
//{
//	int a;
//	int b;
//};
//
//struct Student
//{
//	char name[5];
//	int age;
//	char phone[15];
//	char gender[3];
//	struct P z;
//}Cat={"猫咪",5,"1923812785","女",{10,0}},
//Dog = {"狮王",18,"2938187418","男",{20,0}};
//
//int main()
//{
//	printf("%s,%d,%s,%s,%d,%d\n", Cat.name, Cat.age, Cat.phone, Cat.gender,Cat.z.a, Cat.z.b );
//	printf("%s,%d,%s,%s,%d,%d\n", Dog.name, Dog.age, Dog.phone, Dog.gender, Dog.z.a, Dog.z.b);
//
//	return 0;
//}



//struct p {
//	int a;//4
//	char b;//1
//	float c;//4
//	double d;//8
//
//};
////计算结构体类型的大小
//int main()
//{
//	printf("%zd\n", sizeof(struct p));
//	return 0;
//}



////证明rand函数生成的是伪随机数
//#include <stdlib.h>
//int main()
//{
//	printf("%d\n", rand());
//	printf("%d\n", rand());
//	printf("%d\n", rand());
//	printf("%d\n", rand());
//	printf("%d\n", rand());
//	return 0;
//}


///* srand example */
//#include <stdlib.h>     /* srand, rand */
//#include <time.h>       /* time */
//int main()
//{
//	//以下代码生成随机数范围是0~99
//	printf("First number: %d\n", rand() % 100);//此代码未设置随机数种子，每次运行结果都一样
//	srand((unsigned int)time(NULL));//动态设置随机数种子，每次运行结果都不同
//	printf("Random number: %d\n", rand() % 100);
//	srand(1);//设置随机数种子为1，此结果与未设置随机数种子值一样
//	printf("Again the first number: %d\n", rand() % 100);
//	srand(5);//设置随机数种子为5，只改变一次随机数的生成
//	printf("Again and again the first number: %d\n", rand() % 100);
//
//	return 0;
//}



////计算结构体大小
////引入概念：偏移量，对齐数，对齐方式
//#include <stddef.h>
//struct S1 {		//VS编译器默认对齐数字为8
//	double d;
//	char c;
//	int i;
//};
//
//int main()
//{
//	struct S1 s1 = {0};
//	printf("%zd\n", sizeof(s1));
//	printf("%zd\n", offsetof(struct S1, d));//offsetof宏，计算结构体成员在结构体中的偏移量
//    printf("%zd\n", offsetof(struct S1, c));//偏移量：即成员在结构体中的起始地址与结构体起始地址的差
//	printf("%zd\n", offsetof(struct S1, i));
//	return 0;
//}


//更新计算器
//
//int Add(int a, int b)
//{
//		return a+b;
//}
//int Sub(int a, int b)
//{
//    	return a-b;
//}
//int Mul(int a, int b)
//{
//    	return a*b;
//}
//int Div(int a, int b)
//{
//    	return a/b;
//}
//enum Option {//定义枚举类型
//    EXIT,//0，默认值为0
//    ADD,
//    SUB,
//    MUL,
//    DIV
//};
//void menu()
//{
//    printf("*************************\n");
//    printf("***** 1.add 2.sub ******\n");
//    printf("***** 3.mul 4.div ******\n");
//    printf("***** 0.exit ***********\n");
//}
//
//int main()
//{
//	int input = 0;
//	int a = 0;
//	int b = 0;
//
//	do {
//		menu();
//		scanf("%d", &input);
//		printf("请输入两个操作数：\n");
//		scanf("%d %d", &a, &b);
//		switch (input)
//		{
//			
//			case MUL:
//				Mul(a,b);
//				printf("结果为：%d\n", Mul(a,b));
//                break;
//            case SUB:
//				Sub(a,b);
//				printf("结果为：%d\n", Sub(a,b));
//				break;
//			case DIV:
//                Div(a,b);
//                printf("结果为：%d\n", Div(a,b));
//				break;
//			case ADD:
//                Add(a,b);
//                printf("结果为：%d\n", Add(a,b));
//				break;
//			case EXIT:
//				printf("退出程序\n");
//                break;
//            default:
//				printf("输入错误，请重新输入\n");
//				break;
//		}
//
//	} while (input);
//	return 0;
//}




////计算结构体大小、联合体大小
//union Un
//{
//	short arr[7];
//	int j;
//};
//struct S
//{
//	short arr[7];
//	int i;
//};
//int main()
//{
//	printf("%zd\n", sizeof(struct S));//结构体大小为20
//	printf("%zd\n", sizeof(union Un));//联合体大小为16
//	return 0;
//}



////指针法:计算该编译器是否为小端存储
//int main()
//{
//	int a = 1;
//	if (*(char*)&a == 1)
//	{
//        printf("小端存储\n");
//	}
//	else
//	{
//		printf("大端存储\n");
//	}
//	return 0;
//}



////联合体应用场景：计算该编译器是否为小端存储
////小端存储：低地址存储低位，高地址存储高位
////大端存储：低地址存储高位，高地址存储低位
//union Un {
//	char i;
//	int o;
//
//};
//int main()
//{
//	union Un un = { 0 };
//	un.o = 1;//0x 00 00 00 01 补码（16进制）
//	if (un.i == 1)//如果为小端存储，则1存储的地址为低地址，如果为大端存储，则1存储的地址为高地址
//		//1的小端存储序列：01 00 00 00
//        //1的大端存储序列：00 00 00 01
//	{
//		printf("小端存储\n");
//	}
//	else 
//		printf("大端存储\n");
//	return 0;
//}



////打印0~9的错误码信息
//#include <stdlib.h>
//#include <errno.h>
//#include <string.h>
//int main()
//{
//	for (int i = 0; i <=10; i++)
//	{
//		printf("%s\n", strerror(i));
//		
//	}
//	return 0;
//}


////打印malloc函数错误码信息
//#include <stdlib.h>
//int main()
//{
//	void* p = (void*)malloc(1000000000000000000);
//	if (p == NULL)
//	{
//		perror("malloc");
//		return 1;
//	}
//	free(p);
//    p = NULL;//防止悬空指针
//	return 0;
//}


////打印文件错误码信息
//int main()
//{
//	
//    FILE* pf = fopen("tests.txt", "r");//以只读方式打开文件
//	if (pf == NULL)
//	{
//		perror("fopen");
//		return 1;
//
//	}
//	fclose(pf);
//
//	return 0;
//}


////连续输入并且判断字符是否为字母
//int main()
//{
//	char ch = 0;
//	while ((scanf(" %c", &ch))!=EOF)
//	{
//		if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z'))
//		{
//            printf("%c is an anphabat.\n",ch);
//
//		}
//		else
//		{
//			printf("%c is not an anphabat.\n", ch);
//	
//		}
//		
//	}
//
//	return 0;
//}


////水仙花数:拆分后每个位上的立方之和等于本身
//#include <math.h>
//int main()
//{
//	int ge = 0, shi = 0, bai = 0, qian = 0;
//	for (int i = 0; i <= 9999; i++)
//	{
//		ge = i%10;
//		shi=i/10%10;
//		bai=i/100%10;
//        qian=i/1000;
//		if (i == pow(ge, 3)+pow(shi, 3) + pow(bai,3) + pow(qian,3))
//		{
//           printf("水仙花数为：%d\n", i);
//		}
//	}
//
//	return 0;
//}


////变种水仙花数:拆分后的乘积之和等于本身
//#include <math.h>
//int main()
//{
//	int i = 0;
//	for ( i = 10000; i < 99999; i++)
//	{
//		int a = (i / 10000) * (i % 10000);
//		int b = (i / 1000) * (i % 1000);
//		int c = (i / 100) * (i % 100);
//		int d = (i / 10) * (i % 10);
//		int sum=a+b+c+d;
//		if (i == sum)
//		{
//            printf("变种水仙花数为：%d\n", i);
//		}
//	}
//
//
//	return 0;
//}


////realloc函数和calloc函数实验
//#include <stdlib.h>
//int main()
//{
//	int* ptr = (int*)calloc(25, sizeof(int));
//	if (ptr == NULL)
//	{
//		perror("calloc");
//		return 1;//异常情况退出主函数，终结程序
//	}
//
//	int* p = (int*)realloc(ptr, INT_MAX);
//	if (p == NULL)
//	{
//        perror("realloc");
//        return 1;
//	}
//    	ptr = p;
//	for (int i = 0; i < 10; i++)
//	{
//		*(ptr + i )= i;
//		printf("%d ",*(ptr+i) );
//	}
//	return 0;
//}




////柔性数组
//#include <stdlib.h>
//struct S {//结构体大小为4
//	int n;
//    int arr[];
//};
//int main()
//{
//	struct S* ps = (struct S*)malloc(sizeof(struct S) + 20 * sizeof(int));
//	if (ps == NULL)
//	{
//		perror("malloc");
//	}
//	//使用
//	ps->n = 20;
//	for (int i = 0; i < 20; i++)
//	{
//        ps->arr[i] = i+1;
//
//	}
//	//调整大小
//	struct S* ptr = (struct S*)realloc(ps, sizeof(struct S) + 40 * sizeof(int));
//	if (ptr != NULL)
//	{
//		ps = ptr;
//		ptr = NULL;
//	}
//	else {
//        perror("realloc");
//		return 1;
//	}
//	for (int i = 0; i < 40; i++)
//	{
//		printf("%x ", ps->arr[i]);//%x打印16进制
//	}
//	//释放
//	free(ps);
//    ps = NULL;
//
//	return 0;
//}



////题目：输入一个正整数作为间隔数，然后输出字母表中的字母，要求每 n 个字母换行，并且每 5 个字母后换行。
//int main() {
//	int n=0;
//	printf("请输入一个正整数作为间隔数: ");
//	scanf("%d", &n);
//	if (n <= 0)
//	{
//		printf("输入错误！\n");
//		return 1;
//	}
//	int count = 0; // 用于记录当前已经输出的字符数
//	int isLower = 1; // 用于记录当前应该输出小写还是大写字母
//
//	for (int i = 0; i < 26; i++) 
//	{
//		if (count % n == 0)
//		{
//			isLower = !isLower; // 每隔 n 个字符切换大小写
//			//但每次开头必定是大写字母
//		}
//
//		if (isLower) 
//		{
//			printf("%c", 'a' + i);
//		}
//		else {
//			printf("%c", 'A' + i);
//		}
//		if (i % 5 == 0)//每5个字母换行
//		{
//			printf("\n"); // 输出换行符
//		}
//
//		count++;
//	}
//	
//	return 0;
//}



//#define GENERIC_MAX(type) \
//		type type##_max(type x,type y)\
//		{\
//			return x>y?x:y;\
//		}
//GENERIC_MAX(int);
//GENERIC_MAX(float);
//GENERIC_MAX(char);
//
//void Print(int num)
//{
//	printf("%d\n", num);
//}
//
//int main()
//{
//
//	int result = int_max(100, 200);
//	Print(result);
//	float result2 = float_max(25.9f, 68.4f);
//	printf("%f\n", result2);
//	char result3 = char_max('c', 'P');
//	printf("%c\n", result3);
//	return 0;
//}


////题目：编写一个函数，将一个整数将其每一位顺序输出。
//void Print(int num)
//{
//	if (num > 9)
//		Print(num / 10);
//	printf("%d ", num % 10);
//}
//
//int main()
//{
//	int num = 0;
//	scanf("%d", &num);
//	Print(num);
//
//	return 0;
//}



////题目：编写一个函数，计算并输出一个整数的阶乘。
//int Fact(int number)
//{
//	if (number == 0)
//	{
//		return 1;
//	}
//	else 
//	{
//		return number * Fact(number - 1);
//	}
//}
//
//int main()
//{
//	int num = 0;
//	scanf("%d", &num);
//	int ret = Fact(num);
//	printf("%d\n", ret);
//	return 0;
//}
//#include <stdio.h>
//#include <windows.h>
//#include <string.h>
//int main()
//{
//	char arr1[] = "I have fallen in love with you";
//	char arr2[] = "##############################";
//	int left = 0;
//	int right = strlen(arr1) - 1;
//	printf("%s\n", arr2);
//	while (left <= right)
//	{
//		arr2[left] = arr1[left];
//		arr2[right] = arr1[right];
//		printf("%s\n", arr2);
//		Sleep(1000);//暂停1秒
//        system("cls");//清屏
//		left++;
//		right--;
//	}
//	printf("%s\n", arr2);
//	return 0;
//}



//void fun1()
//{
//	static int i = 0;//i是静态修饰局部变量
//	i++;
//	printf("i=%d\n",i);
//}
//static int j ;//j是修饰的全局变量
//int main()
//{
//	int k = 0;
//	int j = 0;
//	for (k = 0; k < 10; k++)
//	{
//		fun1();
//		j++;
//		
//	}
//	printf("j=%d\n", j);
//	return 0;
//}


//int main()
//{
//	int extend[8][2] = { {0,1},{0,-1},{1,0},{-1,0},{1,1},{1,-1},{-1,1},{-1,-1} };
//	for (int i = 0; i < 8; i++)
//	{
//		for (int j = 0; j < 2; j++)
//		{
//            printf("%2d ", extend[i][j]);
//		}
//		printf("\n");
//	}
//
//	return 0;
//}


//int main()
//{
//	int arr[5] = { 1,2,3,4,5 };
//	int arr2[5] = { 2,3,4,5,6 };
//	int arr3[5] = { 3,4,5,6,7 };
//	int* pstr[3] = { arr,arr2,arr3 };//二维数组指针
//	for (int i = 0; i < 3; i++)
//	{
//		for (int j = 0; j < 5; j++)
//		{
//          	printf("%d ",*(*(pstr+i)+j));
//		}
//		printf("\n");
//	}
//
//
//	return 0;
//}



////二维数组传参：本质是传的首行一维数组的地址
//void zst(int(*p)[5], int row, int col)//二维数组指针接收
//{
//	int i = 0;
//	for (i = 0; i < row; i++)
//	{
//		int j = 0;
//		for (j = 0; j < col; j++)
//		{
//			printf("%d ", *(*(p + i) + j));
//		}
//		printf("\n");
//	}
//}
//int main()
//{
//	int arr[3][5] = { {1,2,3,4,5},{6,7,8,9,10},{11,12,13,14,15} };
//	zst(arr, 3, 5);
//	return 0;
//}

////函数指针
//static int Add(int a, int b)
//{
//    	return a + b;
//}
//int main()
//{
//	int a = 4;
//	int b = 6;
//	int(*pf)(int,int) = Add;//函数指针创建
//	int r = pf(a, b);//函数指针调用
//	int r2 = (*pf)(a, b);//函数指针调用
//	printf("%d\n", r);
//    printf("%d\n", r2);
//	return 0;
//}


////转移表
//int ADD(int a, int b)
//{
//	return a + b;
//}
//int SUB(int a, int b)
//{
//    return a - b;
//}
//int MUL(int a, int b)
//{
//	return a * b;
//}
//int DIV(int a, int b)
//{
//	return a / b;
//}
//void menu()
//{
//	printf("*********************************\n");
//	printf("******1.加法程序****2.减法程序****\n");
//	printf("******3.乘法程序****4.除法程序****\n");
//	printf("*********0.退出计算器*************\n");
//	printf("********************************\n");
//}
//int main()
//{
//	int input = 0;
//	int a = 0, b = 0, ret = 0;
//	int(*pf[5])(int , int ) = { 0,ADD,SUB,MUL,DIV };//函数指针数组
//	do
//	{
//		menu();
//		printf("请选择计算器服务：>\n");
//		scanf("%d", &input);
//		if ((input <= 4 && input >= 1))
//		{
//			printf("输入操作数：");
//			scanf("%d %d", &a, &b);
//			ret = (*pf[input])(a,b);
//			printf("ret = %d\n", ret);
//		}
//		else if (input == 0)
//		{
//			printf("退出计算器\n");
//		}
//		else
//		{
//			printf("输入有误\n");
//		}
//	} while (input);
//	
//
//	return 0;
//}


//内存布局调试代码
//#include <stdlib.h>
//
//// 全局变量，存储在全局/静态区
//int globalVar = 10;
//// 静态全局变量，存储在全局/静态区
//static int staticGlobalVar = 20;
//
//int main() {
//    // 局部变量，存储在栈区
//    int localVar = 30;
//
//    // 动态分配内存，存储在堆区
//    int* heapVar = (int*)malloc(sizeof(int));
//
//	if (heapVar != NULL) {
//        *heapVar = 40;
//    }
//
//    // 字符串常量，存储在常量区
//    const char* str = "Hello, World!";
//	
//    printf("globalVar address: %p\n", &globalVar);
//    printf("staticGlobalVar address: %p\n", &staticGlobalVar);
//    printf("localVar address: %p\n", &localVar);
//    printf("heapVar address: %p\n", heapVar);
//    printf("str address: %p\n", str);
//
//    // 释放堆区内存
//    if (heapVar != NULL) {
//        free(heapVar);
//        heapVar = NULL;
//    }
//
//    return 0;
//}


//void sky(int bah)//bah==pooh=2
//{
//	int pooh = 10;
//    printf("pooh address: %p and pooh= %d\n", &pooh,pooh);
//    printf("bah address: %p and bah= %d\n", &bah,bah);
//}
//int main()//问题：&pooh和&bah的地址谁大？
//{
//	int pooh = 2, bah = 5;
//	//局部变量，存储在栈区
//	printf("pooh address: %p and pooh= %d\n", &pooh,pooh);
//	printf("bah address: %p and bah= %d\n", &bah,bah);
//	//自定义函数sky
//	sky(pooh);
//	printf("pooh=%d\n", pooh);
//	printf("bah=%d\n", bah);
//	return 0;
//}


////代码1 - 测试⽆const修饰的情况
//void test1()
//{
//	int n = 10;
//	int m = 20;
//	int* p = &n;
//	*p = 20;//ok
//	p = &m; //ok
//}
////代码2 - 测试const放在*的左边情况
//void test2()
//{
//	int n = 10;
//	int m = 20;
//	const int* p = &n;
//	*p = 20;//error
//	p = &m; //ok
//}
////代码3 - 测试const放在*的右边情况
//void test3()
//{
//	int n = 10;
//	int m = 20;
//	int* const p = &n;
//	*p = 20; //ok
//	p = &m; //error
//}
////代码4 - 测试*的左右两边都有const
//void test4()
//{
//	int n = 10;
//	int m = 20;
//	int const* const p = &n;
//	*p = 20; //error
//	p = &m; //error
//}
//int main()
//{
//	//测试⽆const修饰的情况
//	test1();
//	//测试const放在*的左边情况
//	test2();
//	//测试const放在*的右边情况
//	test3();
//	//测试*的左右两边都有const
//	test4();
//	return 0;
//}

//int my_strlen(char* arr)
//{
//	char* head = arr;//头指针记录最初始的位置
//	while (*arr)//当*arr=='\0'时，循环结束
//	{
//		arr++;//循环结束后arr会指向'\0'
//	}
//	return arr - head;//所以arr - head = 字符串长度
//}
//int main()
//{
//	char arr[] = "abc";//字符串长度实际上是4，因为最后有一个'\0'
//	printf("%d\n",my_strlen(arr));
//	return 0;
//}


//int main()
//{
//	int a[] = { 1,2,3,4,5 };//5
//	int* pa = a;
//	int* pb = &a[4];
//	printf("两数组区间差值为：%d\n",pa-pb );
//
//	return 0;
//}


//int main()
//{
//	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
//	int* p = &arr[0];//指针p指向数组arr的首元素
//	int sz = sizeof(arr) / sizeof(arr[0]);
//	while (p < arr + sz) //指针的大小⽐较
//	{
//		//arr+sz:指向数组arr的最后一个元素的后一个位置
//		printf("%d ", *p);
//		p++;
//	}
//	return 0;
//}

//int main()
//{
//	int* p;//局部变量指针未初始化，默认为随机值
//	*p = 20;
//	return 0;
//}




//int* test()
//{
//    int a = 10;
//	return &a;
//}
//int main()
//{
//	int* pa=test();
//	printf("%d\n",*pa);
//	return 0;
//}


//int main()
//{
//	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
//	int* p = arr;
//	for (int i = 0; i < 10; i++)
//	{
//		*(p++) = i;
//	}
//	//当走到这里的时候p已经等于arr+10了，此时p指向了数组arr的最后一个元素的后一个位置
//	//我们可以把p置为NULL
//	p = NULL;
//	//下次使⽤的时候，判断p不为NULL的时候再使⽤
//	
//	p = arr;//重新让p获得地址
//	if (p != NULL) //判断
//	{
//		*p = 100;
//	}
//	return 0;
//}



////优化计算字符串个数的函数
//#define NDEBUG
//#include<assert.h>
//size_t my_strlen(const char* str)//const修饰指针，防止指针指向的值被修改
//{
//	size_t count = 0;
//	assert(str != NULL);//断言，防止传入空指针
//	while (*str)//*str != '\0','\0'的ASCII码值为0
//	{
//		count++;
//		str++;
//	}
//	return count;
//}
//int main()
//{
//	char arr[] = { "abcdef" };
//	size_t len = my_strlen(NULL);//返回值是size_t类型（无符号整形）
//	printf("%zd\n", len);
//	return 0;
//}



//void Swap(int* m, int* n)
//{
//	int tmp =*m;
//	*m = *n;
//	*n= tmp;
//}
//int main()
//{
//	int a = 10, b = 20;
//	int* pa = &a, * pb = &b;
//	printf("交换前：\n");
//	printf("a=%d b=%d\n", a, b);
//	Swap(pa, pb);
//	printf("交换后：\n");
//    printf("a=%d b=%d\n", a, b);
//	return 0;
//}





//int main()
//{
//	for (int i = 1; i <= 4; i++)
//	{
//		for (int j = 1; j <= 5; j++)
//		{
//			printf("%-3d", i * j);
//			
//		}
//		printf("\n");
//	}
//	return 0;
//}







//#include <string.h>
//struct Student
//{
//	char name[10];
//	char sex[5];
//	int phone;
//	int id;
//}s1;
//
//int main()
//{
//	strcpy(s1.name,"zhangsan");//把字符串"zhangsan"复制到s1.name中
//	//错误写法：s1.sex="male";因为s1.sex是一个字符数组，不是指针，不能直接赋值
//    strcpy(s1.sex, "male");
//    s1.phone = 123456789;
//    s1.id = 20210001;
//	printf("name:%s\nsex:%s\nphone:%d\nid:%d\n", s1.name, s1.sex, s1.phone, s1.id);
//	printf("%d\n", sizeof(s1));
//	return 0;
//}



//int main()
//{
//	void(*signal(int, void(*)(int)))(int);
//	//此代码是一次函数指针的声明
//	//void(*)(int) signal(int, void(*)(int));其实准确来说，这样写更好理解，但是编译器不认
//	return 0;
//}




//int Add(int x, int y)
//{
//	return x + y;
//}
////typedef 重命名
//typedef int* pint;//整形指针重命名
////错误示范：typedef int(*)[6] parr;编译器只认把重命名放到星号的后面
//typedef int(*parr)[6];//数组指针重命名
//typedef int(*pf1)(int, int);//函数指针重命名
//int main()
//{
//	int* pf= NULL;
//    pint p = NULL;//pint是int*的别名
//
//	int arr[6] = { 0 };
//	int(*pa)[6] = arr;//pa是一个数组指针，指向一个大小为6的整形数组
//	//数组指针类型：int(*)[6]
//	parr pa1= arr;//用新类型名去创建数组指针
//
//	int(*pf)(int, int) = Add;//pf是一个函数指针，指向一个返回值为int，参数为两个int的函数
//	//函数指针类型：int(*)(int,int)
//    pf1 pf2 = Add;//用新类型名去创建函数指针
//
//	return 0;
//}


////双指针解法
//int remove_element(int* nums, int numsSize, int val)
//{
//	//定义两个指针
//	int src, dst;
//	src = dst = 0;
//	while (src != numsSize)//当src指针到达数组末尾时，结束循环
//	{
//		//当src指向的元素和val吻合时，src指针后移
//		if (nums[src] == val)
//		{
//			src++;
//		}
//		else
//		{
//			//当src指向的元素和val不吻合时，将src指向的元素赋值给dst指向的元素，然后src和dst指针都后移
//			nums[dst++] = nums[src++];
//		}
//	}
//	return dst;
//}
////把数组里的元素等于val的除去，返回新数组的长度
//int main()
//{
//	int arr[] = { 3,2,2,3 };
//	int size = sizeof(arr) / sizeof(arr[0]);
//	int val = 3;
//	printf("原数组遍历:");
//	for (int i = 0; i < size; i++)
//	{
//		printf("%d ", *(arr + i));
//	}
//	printf("\n");
//	int element=remove_element(arr, size, val);
//	printf("移除后的数组长度为：%d\n", element);
//	printf("移除后新的数组:");
//	for (int i = 0; i < element; i++)
//	{
//		printf("%d ", arr[i]);
//	}
//	
//	return 0;
//}



//void merge(int* num1, int m, int* num2, int n)
//{
//	//定义两指针分别指向num1的有效数据的末尾和num2的末尾
//	int l1 = m - 1;
//	int l2 = n - 1;
//	//定义一个指针指向num1的末尾
//	int l3 = m + n - 1;
//	while (l1 >= 0 && l2 >= 0)
//	{
//		//比较两数组的有效数据，将较大的数放到num1的末尾
//		if (num1[l1] > num2[l2])
//		{
//			num1[l3--] = num1[l1--];
//		}
//		else {
//            num1[l3--] = num2[l2--];
//		}
//		
//	}
//	//如果num2还有剩余，则直接放到num1的前面
//	while (l2 >= 0)
//	{
//		num1[l3--] = num2[l2--];
//	}
//}
////合并有序数组
//#define array1 6
//#define array2 3
//#define valid1 3
//int main()
//{
//	int arr[array1] = { 4,5,6};
//	//计算有效数据长度
//	int seed = sizeof(arr) / sizeof(arr[0]);
//	int arr2[array2] = { 1,2,3};
//	int leng = sizeof(arr2) / sizeof(arr2[0]);
//	//将arr2中的元素合并到arr中
//	merge(arr, valid1, arr2, leng);
//	int i = 0;
//	printf("合并后的数组arr为:\n");
//	for (i = 0; i < seed; i++)
//	{
//		printf("%d ", arr[i]);
//	}
//	return 0;
//}



////力扣203T：移除链表元素
//typedef struct ListNode ListNode;
//
//struct ListNode* removeElements(struct ListNode* head, int val) {
//    //创建新链表接受非移除元素节点
//    ListNode* newHead, * newTail;
//    newHead = newTail = NULL;
//    ListNode* pcurrent = head;
//    while (pcurrent != NULL)
//    {
//        //把值不为val的节点进行移动
//        if (pcurrent->val != val)
//        {
//            //新创建链表有两种状态：空链表和非空链表
//            if (newHead == NULL)
//            {
//                newHead = newTail = pcurrent;
//            }
//            else {
//                //尾插
//                newTail->next = pcurrent;
//                newTail = newTail->next;
//            }
//        }
//        pcurrent = pcurrent->next;
//    }
//    //最后备份完可能最后5指针的节点仍然指向6节点
//    if (newTail != NULL)
//    {
//        newTail->next = NULL;
//    }
//    return newHead;
//}


////力扣206：反转链表
//typedef struct ListNode ListNode;
//struct ListNode* reverseList(struct ListNode* head) {
//	//提示已经告诉可能传空链表反转
//	if (head == NULL)
//	{
//		return head;
//	}
//
//	//三指针解法,不需要额外创建新链表
//	ListNode* n1, * n2, * n3;
//	n1 = NULL, n2 = head, n3 = n2->next;
//	while (n2)
//	{
//		n2->next = n1;
//		n1 = n2;
//		n2 = n3;
//		if (n3)//可能对空指针进行解引用
//			n3 = n3->next;
//	}
//	return n1;
//
//}


////力扣876：链表的中间节点
////方法：快慢指针
//typedef struct ListNode ListNode;
//struct ListNode* middleNode(struct ListNode* head) {
//	//快慢指针
//	ListNode* slow, * fast;
//	slow = fast = head;
//	while (fast && fast->next)//里面循环条件不可交换位置，短路与，否则会出现对空指针进行解引用
//	{
//		slow = slow->next;
//		fast = fast->next->next;
//	}
//	return slow;
//
//}


//////力扣21：合并两个有序链表
//////方法：哨兵位+尾插法
//typedef struct ListNode ListNode;
//struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2) {
//    //可能两个链表为空 
//    if (list1 == NULL)
//    {
//        return list2;
//    }
//    if (list2 == NULL)
//    {
//        return list1;
//    }
//    ListNode* l1, * l2;
//    l1 = list1, l2 = list2;
//    ListNode* newHead, * newTail;
//    newHead = newTail = (ListNode*)malloc(sizeof(ListNode));//哨兵位
//    while (l1 && l2)
//    {
//        if (l1->val < l2->val)
//        {
//            //l1拿下来尾插
//            newTail->next = l1;
//            newTail = newTail->next;
//            l1 = l1->next;
//        }
//        else {
//            //l2拿下来尾插
//            newTail->next = l2;
//            newTail = newTail->next;
//            l2 = l2->next;
//        }
//
//    }
//    //要么l1为空，要么l2为空
//    if (l1 == NULL)
//    {
//        newTail->next = l2;
//    }
//    if (l2 == NULL)
//    {
//        newTail->next = l1;
//
//    }
//    ListNode* ret = newHead->next;
//    free(newHead);
//    newHead = NULL;
//    return ret;
//}





////编写函数fun, 其功能是：求出1~100之间能被8或9整除，但不能同时被8和9整除的所有整数，并将其放在a所指的数组中，通过n返回这些数的个数
//void fun(int* arr, int* n)
//{
//	int count = 0;
//	for (int i = 1; i <= 100; i++)
//	{
//		if (((i % 8 == 0) || (i % 9 == 0)) && !((i % 8 == 0) && (i % 9 == 0)))
//		{
//			arr[count]=i;
//			count++;
//		}
//	}
//	*n = count;
//}
//int main()
//{
//	int arr[25], n = 0;
//	fun(arr, &n);
//	for (int i = 0; i < n; i++)
//	{
//		printf("%d ", arr[i]);
//	}
//	return 0;
//}


////公式x = 1 + 1 / 1! + 1 / 2! + 1 / 3!+ ......, 求x的近似值，精度为10的 - 5次方。
//double fun(double f)
//{
//    double x = 1.0;
//	double sum = 0;
//	double fact = 1.0;
//	int i = 1;
//	while (1.0 / i >= f)
//	{
//		sum += 1.0 / i;
//		i++;
//		fact *= i;
//	}
//	return sum;
//}
//int main() {
//	
//    // 输出结果
//    printf("x 的近似值为: %lf\n", fun(10e-5));
//
//    return 0;
//}




////求两个正整数m和n的最大公约数。(辗转相除法)
//int fun(int m, int n)
//{
//	int c = 0;
//	while (m%n)
//	{
//		c = m % n;
//		m = n;
//		n = c;
//	}
//	return n;
//}
//int main()
//{
//	int m = 0, n = 0;
//	scanf("%d %d", &m, &n);
//	printf("%d ", fun(m, n));
//	return 0;
//}



////一小球从100米落下，每次弹跳原来一半高，求第10次落地时经过的距离及第10次弹跳的高度。
//int main()
//{
//	double height = 100.0;
//	double distance = 100.0;
//	for (int i = 1; i < 10; i++)
//	{
//		height /= 2;
//		distance += 2 * height;//每次落下的距离是弹跳距离的两倍
//	}
//	height /= 2;//最后一次弹跳的高度
//    printf("第10次落地时经过的距离为: %lf\n", distance);
//    printf("第10次弹跳的高度为: %lf\n", height);
//	return 0;
//}


////编写函数（fun），使用冒泡法对数组a进行由小到大的排序。
//void sorted(int* arr,int seed)
//{
//	int i = 0, j = 0;
//	for (i = 0; i < seed-1; i++)
//	{
//		for (j = 0; j < seed - 1 - i; j++)
//		{
//			if (arr[j] >arr[j + 1])
//			{
//				int tmp = arr[j];
//				arr[j] = arr[j + 1];
//				arr[j + 1] = tmp;
//			}
//		}
//	}
//}
//int main()
//{
//	int a[] = { 13,8,5,11,2,6,9,7,19,100,99,54 };
//	int seed = sizeof(a) / sizeof(a[0]);
//	int i = 0;
//	sorted(a,seed);
//	printf("排序后的数组为：\n");
//	for (int i = 0; i < seed; i++)
//	{
//		printf("%d ", *(a + i));
//	}
//	return 0;
//}



////输入一个正整数，按从低位到高位的顺序，依次将其偶数位上的数字取出，反序重新生成一个整数并输出，例如，输入112233，则输出321 。
//int fun(int n)
//{
//	int s, t;
//	s = 0;
//	n = n / 10;//去掉个位
//	
//	while (n)
//	{
//		t = n % 10;//取个位
//		s = s * 10 + t;//将个位加到s的十位上
//		n = n / 100;//去掉个位和十位
//	}
//	return s;
//			
//}
//
//#include <math.h>
//int main()
//{
//	int a;
//	printf("请输入一个整数：");
//	scanf("%d", &a);
//	printf("重新生成的整数是：%d\n", fun(a));
//	return 0;
//}


////如果一个数恰好等于除它本身外的所有因子之和，则这个数就称为完数。例如：6的因子是1、2、3，且6=1+2+3，所以6是完数。试求1000以内所有的完数并输出
//
//int main() {
//	int i, j, sum;
//
//	// 遍历2到1000的每个数
//	for (i = 2; i <= 1000; i++) {
//		sum = 0;
//		// 找出当前数i的所有因子并求和
//		for (j = 1; j < i; j++) {
//			if (i % j == 0) {
//				sum += j;
//			}
//		}
//		// 判断是否为完数
//		if (sum == i) {
//			printf("%d 是完数\n", i);
//		}
//	}
//
//	return 0;
//}




////将一个字符串中的前N个字符复制到一个字符数组中去，不许使用strcpy函数。输入：aaabbbccc    输出：aaa
//
//int main()
//{
//	char str1[100]={0}, str2[100] = {0};
//	int N = 0, i = 0;
//	printf("请输入一个字符串：");
//	char ch = 0;
//	while (((ch = getchar()) != '\n') && (i < 100 - 1))
//	{
//		str1[i] = ch;//将输入的字符存入数组
//		i++;
//	}
//	printf("请输入要复制的字符个数：");
//	scanf("%d", &N);
//	for (i = 0; i < N; i++)
//	{
//		str2[i] = str1[i];//将前N个字符复制到str2中
//	}
//	str2[N] = '\0';//字符串结束符
//	printf("%s", str2);
//	return 0;
//}


//枚举类型复习
//enum Day {
//	MONDAY,//默认值为0
//	TUESDAY,
//	WEDNESDAY, 
//	THURSDAY,
//	FRIDAY,
//	SATURDAY,
//	SUNDAY
//};
//
//enum Color {
//	red=(enum Color)2,//遵循类型相同赋值的原则
//	blue=3,
//	yellow=5,
//	purple=10
//};
//
//int main()
//{
//	enum Day day1 = MONDAY;
//	enum Color color1 = red;
//	printf("day1 is %d\n", day1);
//	printf("color1 is %d\n", color1);
//	return 0;
//}



////联合体类型
//union Un {
//	int a;
//    char b;
//};//只为最大的成员分配空间
//
//int main()
//{
//	union Un un = { 0 };
//	un.b = 'w';
//	un.a = 10;
//
//	printf("联合体Un的大小为：%zd\n", sizeof(union Un));//4
//
//	printf("联合体un的总地址为：%p\n", &un);
//	printf("联合体成员a的地址为：%p\n", &un.a);
//	printf("联合体成员b的地址为：%p\n", &un.b);
//	return 0;
//}



////联合体成员同时使用会导致数据覆盖
//union Un
//{
//	char c;
//	int i;
//};
//int main()
//{
//	//联合变量的定义
//	union Un un = { 0 };
//	//成员i和成员c不能同时使用,因为他们共用同一块空间，
//	// 所以使用一个后，另一个的值会被覆盖
//	un.i = 0x11223344;
//	un.c = 0x55;
//	printf("%x\n", un.i);
//	return 0;
//}


////联合体存在内存对齐
////当最大成员大小不是最⼤对齐数的整数倍的时候，就要对齐到最⼤对齐数的整数倍
//union UN1 {
//	char c[5];//5
//	//相当于五个char类型的变量，每个变量占一个字节
//	//所以5个char c  计算其对齐数 ：  自身大小为1 ，默认对齐数为8 ，所以对齐数为1
//
//	int a;//4
//	//自身大小为4，默认对齐数为8，所以对齐数为4
//
//	//所以总对齐数为4，因为char c[5]占了5个字节，所以UN1的总大小为4的倍数，所以为8
//};
//union UN2 {
//	short s[7];//14
//	//相当于7个short类型的变量，每个变量占两个字节
//    //所以7个short s  计算其对齐数 ：  自身大小为2 ，默认对齐数为8 ，所以对齐数为2
//
//	int i;//4
//    //自身大小为4，默认对齐数为8，所以对齐数为4
//
//    //所以总对齐数为4，因为short s[7]占了14个字节，所以UN2的总大小为4的倍数，所以为16
//};
//int main()
//{
//	printf("%zd\n", sizeof(union UN1));
//	printf("%zd\n", sizeof(union UN2));
//	return 0;
//}


////联合体使用情况
////比如，我们要搞⼀个活动，要上线⼀个礼品兑换单，礼品兑换单中有三种商品：图书、杯子、衬衫。
////每⼀种商品都有：库存量、价格、商品类型和商品类型相关的其他信息。
////1. 图书：书名、作者、页数
////2. 杯子：设计
////3. 衬衫：设计、可选颜色、可选尺寸
//
//typedef struct gift_list
//{
//	//公共属性
//	int stock_number;//库存量
//	double price; //定价
//	int item_type;//商品类型
//	union {
//		struct 
//		{
//			char title[20];//书名
//			char author[20];//作者
//			int num_pages;//⻚数
//		}book;
//		struct {
//			char design[30];//设计
//		}mug;
//		struct {
//			int colors;//颜⾊
//			int sizes;//尺⼨
//		}shirt;
//
//	}item;
//}gift;
//
//
//int main()
//{
//	gift gift1 = { 0 };
//	gift1.stock_number = 100;
//	gift gift2 = { 0 };
//	 //错误代码：gift2.item.mug.design = "mug design";
//	gift2.item.mug.design[0] = 's';
//	gift2.item.mug.design[5] = 'w';
//	printf("%s\n", gift2.item.mug.design);//用%s输出，因为字符串以'\0'结尾
//	return 0;
//}




////写⼀个程序，判断当前机器是⼤端？还是⼩端？
//union UN {
//	char a;
//	int b;
//};
//int main()
//{
//	union UN un = { 0 };
//	//赋值操作
//	un.b = 1;
//	if (un.a == 1)
//	{
//		printf("小端\n");
//	}
//	else {
//		printf("大端\n");
//	}
//	return 0;
//}




//#include <memory.h>
//#include <assert.h>
////内存拷贝memcpy函数
//void* my_memcpy(void* dest, const void* src, size_t num)
//{
//	assert(dest && src);//防止传入空指针
//	size_t i = 0;
//	void* temp = dest;//保存目标地址，防止返回值出错
//	for (i=0; i < num; i++)
//	{
//		*(char*)dest = *(char*)src;
//		dest = (char*)dest + 1;
//		src = (char*)src + 1;
//	}
//	return temp;
//}
//
//int main()
//{
//	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
//	int arr2[20] = { 0 };
//	int seed = sizeof(arr2) / sizeof(arr2[0]);
//	my_memcpy(arr2, arr1 + 2, 5 * sizeof(int));
//	for (int i = 0; i < seed; i++)
//	{
//		printf("%d ", arr2[i]);
//	}
//	return 0;
//}



//#include <string.h>
//#include <assert.h>
//void* my_memmove(void* dest, const void* src, size_t num)
//{
// 
//	void * tmp= dest;//保存目标地址，防止返回值出错
//	if (dest < src)//从前向后拷贝
//	{
//		while (num--)
//		{
//			*(char*)dest = *(char*)src;
//			dest = (char*)dest + 1;
//			src = (char*)src + 1;
//		}
//	}
//	else 
//	{
//		//从后向前拷贝
//		while (num--)
//		{
//			*((char*)dest + num) = *((char*)src + num);//两指针末尾值覆盖
//		}
//	}
//	return tmp;
//}
//int main()
//{
//	int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
//	//把12345拷贝到34567的位置
//	my_memmove(arr1 + 7, arr1, 3 * sizeof(int));
//	for (int i = 0; i < 10; i++)
//	{
//		printf("%d ", arr1[i]);
//	}
//	return 0;
//}


//#include <string.h>
////memset内存函数
//int main()
//{
//	//特例：
//	int arr2[10] = { 0 };
//	//把整形数组的前四个元素设置为1，按字节拷贝
//	memset(arr2, 10, 4*sizeof(int));
//
//	return 0;
//} 




////memcmp函数
//#include <string.h>
//int main()
//{
//	int arr1[5] = { 1,2,3,4,5 };
//	int arr2[5] = { 1,2,3,6,8 };
//	int ret=memcmp(arr1, arr2, 4 * sizeof(int));
//	if (ret == 0)
//	{
//		printf("相等\n");
//	}
//	else if (ret > 0)
//	{
//        printf("arr1大于arr2\n");
//	}
//	else 
//		printf("arr1小于arr2\n");
//	return 0;
//}


////数据存储发生截断和整形提升
//int main()
//{
//	char a = -1;
//	//原码：1000 0000 0000 0000 0000 0000 0000 0001
//	//反码:1111 1111 1111 1111 1111 1111 1111 1110
//	//补码:1111 1111 1111 1111 1111 1111 1111 1111
//	//发生截断存储char a = -1 :1111 1111 ,a数据类型是有符号char
//	//打印a=%d时，有符号的负数发生整形提升，高位是1，补1，
//	// 即补码为1111 1111 1111 1111 1111 1111 1111 1111
//	//反码为1111 1111 1111 1111 1111 1111 1111 1110
//	//原码为1000 0000 0000 0000 0000 0000 0000 0001
//	//即a=%d,打印的是-1
//	signed char b = -1;//和char a = -1存储方式一样，打印方式也是一样
//	unsigned char c = -1;
//	//原码：1000 0000 0000 0000 0000 0000 0000 0001
//	//反码:1111 1111 1111 1111 1111 1111 1111 1110
//	//补码:1111 1111 1111 1111 1111 1111 1111 1111
//	//发生截断存储unsigned char c = -1 :1111 1111 ,c数据类型是无符号char
//	//c数据发生整形提升，高位补0，即补码为0000 0000 0000 0000 0000 0000 1111 1111
//	//打印c=%d时，正数的原码和补码相同，即c=%d,打印的是255
//
//	printf("a=%d ,b=%d,c=%d\n", a, b, c);//打印数据是展示原码
//	
//}


//int main()
//{
//	char a = 128;
//	//正数原码即补码:0000 0000 0000 0000 0000 0000 1000 0000
//	//发生截断:1000 0000
//	//整形提升：由于是char类型，是有符号数，且a是正数,高位补1
//	//打印%u 即正数的补码为1111 1111 1111 1111 1111 1111 1000 0000
//	printf("%u\n", a);//特大的数
//	return 0;
//}



////'\0'、0、NULL的区别
//int main() {
//	// "\0" 是包含两个 '\0' 的字符串
//	char str[] = "\0";
//	printf("str 长度（含结束符）: %zu\n", sizeof(str)); // 输出 2
//
//	// 0 作为整数和空指针
//	int num = 0;
//	int* ptr1 = 0; // 合法，空指针
//	int* ptr2 = NULL; // 合法，等价于 ptr1
//
//	// '\0' 是 ASCII 值为 0 的字符
//	char end = '\0';
//	printf("end 的值: %d\n", end); // 输出 0
//
//	return 0;
//}



////char数据类型取值范围
//#include <string.h>
//unsigned char i = 0;//全局变量
//int main()
//{
//	//char a[1000];
//	//int i;
//	//for (i = 0; i < 1000; i++)
//	//{
//	//	a[i] = -1 - i;//-1 -2  -3 ...127  -128 -127...-3 -2 -1 0
//	//}
//	//printf("%zd\n", strlen(a));//遇到'\0'结束，所以打印的是127+(-128的绝对值)=255
//
//	for (i = 0; i <= 255; i++)
//	{
//		printf("I love you\n");
//	}
//	return 0;
//}


////指针强转为数据类型
//int main()
//{
//	int a[4] = { 1,2,3,4 };//内存中:01 00 00 00 02 00 00 00 03 00 00 00 04 00 00 00
//	int* ptr1 = (int*)(&a + 1);//&a+1跳过整个数组，指向数组后面的地址
//	int* ptr2 = (int*)((int)a + 1);//把a的地址强制类型转换为int，再+1，ptr2指向a的后一个字节
//	//即ptr2指向01 00 00 00的后一个字节，即指向02 00 00 00
//    printf("%#x,%#x\n", ptr1[-1], *ptr2);//ptr1[-1]=*(ptr1-1)=4,ptr2指向02 00 00 00，*ptr2向后访问4个字节，即02 00 00 00
//	//%x打印16进制，%#x打印16进制并带0x
//	return 0;
//}

////练习
//int main()
//{
//	int n = 9;
//	float* pFloat = (float*)&n;
//	printf("n的值为：%d\n", n);
//	printf("*pFloat的值为：%f\n", *pFloat);
//	*pFloat = 9.0;
//	printf("num的值为：%d\n", n);
//	printf("*pFloat的值为：%f\n", *pFloat);
//	return 0;
//}  


//浮点型数据误差
//#include <math.h>
//int main()
//{
//	float f = 8.8f;
//	if (fabs(f - 8.8) < 0.000001)
//	{
//		printf("原值在误差值以内，相等\n");
//	}
//	else
//	{
//		printf("原值在误差值以外，不相等\n");
//	}
//	return 0;
//}


////测试数学库函数
////fabs 函数来测试误差
//#include <math.h>
//int main()
//{
//	float f = 8.8f;//二进制表示法：1000.1100
//	if (fabs(f-8.8) < 0.000001)
//	{
//		printf("原值在误差值以内，相等\n");
//	}
//	else {
//		printf("原值在误差值以外，不相等\n");
//	}
//	return 0;
//}


////测试abs函数
//#include <math.h>
//int main()
//{
//	int n, m;
//	n = abs(23);
//	m = abs(-11);
//	printf("n=%d\n", n);
//	printf("m=%d\n", m);
//	return 0;
//}

////测试pow函数
//#include <math.h>
//int main()
//{
//	double x, y;
//	x = 2.0, y = 3.0;
//	double ret = pow(x, y);
//	printf("ret=%lf\n", ret);
//	return 0;
//}


////测试sqrt函数
//#include <math.h>
//int main()
//{
//	float x;
//	x = 2.0f;
//	if (x < 0)
//	{
//		printf("x is negative\n");
//		return 1;
//	}
//	double ret= sqrt(x);
//	printf("ret=%lf\n", ret);
//	return 0;
//}


////写⼀个代码，将字符串中的⼩写字⺟转⼤写，其他字符不变
//#include <ctype.h>
//int main()
//{
//	int i = 0;//遍历
//	char str[] = "Test String.\n";
//	char c;
//	while (str[i])
//	{
//		c = str[i];
//		if (islower(c))
//		{
//			c = toupper(c);
//		}
//		putchar(c);
//		i++;
//	}
//	return 0;
//}


////用tolower函数修改上面代码
//#include <ctype.h>
//int main()
//{
//	int i = 0;//遍历
//	char str[] = "Test String.\n";
//	char c;
//	while (str[i])
//	{
//		c = str[i];
//		if (isupper(c))
//		{
//			c = tolower(c);
//		}
//		putchar(c);
//		i++;
//	}
//	return 0;
//}


////strlen函数
//#include <string.h>
//int main()
//{
//		const char* str1 = "abcdef";
//		const char* str2 = "bbb";
//		if (strlen(str2) - strlen(str1) > 0)
//		{
//			printf("str2>str1\n");
//		}
//		else
//		{
//			printf("srt1>str2\n");
//		}
//		return 0;
//}



//模拟实现strlen函数
//方法一：计算器
//size_t my_strlen(char* str)
//{
//	int count = 0;
//	while (*str)
//	{
//		count++;
//		str++;
//	}
//	return count;
//}
//int main()
//{
//	char s[] = "Happy";
//	size_t num=my_strlen(s);
//	printf("该数组长度:%zd", num);
//	return 0;
//}


////方法二: 递归
//size_t my_strlen(char* str)
//{
//	if (*str == '\0')
//		return 0;
//	else
//		return 1+my_strlen(str + 1);
//}
//int main()
//{
//	char s[] = "Happy";
//	size_t num = my_strlen(s);
//	printf("该数组长度:%zd", num);
//	return 0;
//}



////方法三: 指针 减去 指针
//size_t my_strlen(char* str)
//{
//	char* tmp = str;
//	while (*tmp)
//	{
//		tmp++;
//	}
//	return tmp-str;
//}
//int main()
//{
//	char s[] = "Happy";
//	size_t num = my_strlen(s);
//	printf("该数组长度:%zd", num);
//	return 0;
//}





//enum opt {
//	INT='i',
//	Float='f',
//	Char='c'
//};
////通用打印函数
//void print(void* data, char type)
//{
//	switch (type) 
//	{
//	case 'i': printf("%d\n", *(int*)data); break;
//	case 'f': printf("%f\n", *(float*)data); break;
//	case 'c': printf("%c\n", *(char*)data); break;
//	}
//}
//int main()
//{
//	int i1 = 10;
//	int* p1 = &i1;
//	float f1 = 1.1f;
//	float* p2 = &f1;
//	char c1 = 'a';
//	char* p3 = &c1;
//	print(p1, INT);
//	print(p2, Float);
//	print(p3, Char);
//	return 0;
//}

//#include <string.h>
////strcpy函数使用
//int main()
//{
//	char str1[] = "Sample string";
//	char str2[40];
//	char str3[40];
//	strcpy(str2, str1);
//	strcpy(str3, "copy successful");
//	printf("str1: %s\nstr2: %s\nstr3: %s\n", str1, str2, str3);
//	return 0;
//}


////模拟实现strcpy函数
//#include <assert.h>
//char* my_strcpy(char* dest, char* src)
//{
//	assert(dest && src);
//	char* ret = dest;
//	while (*src != '\0')
//	{
//		*dest++=*src++;
//	}
//	*dest = *src;//手动一个'\0'
//	return ret;
//}
//int main()
//{
//	char str[] = "You are so adorable!";
//	char dest[40]={0};
//	char* pdest=my_strcpy(dest, str);
//	printf("%s\n", pdest);
//	return 0;
//}




///* strcat example */
//#include <string.h>
//
//int main()
//{
//	char str[80];
//	strcpy(str, "these ");
//	strcat(str, "strings ");
//	strcat(str, "are ");
//	strcat(str, "concatenated.");
//	puts(str);
//	return 0;
//}


////模拟实现strcat函数
//#include <assert.h>
//char* my_strcat(char* dest, const char* src)
//{
//	assert(dest && src);
//	char* tmp = dest;
//	while (*dest)
//	{
//		dest++;
//	}
//	while (*dest++ = *src++)
//	{
//		;
//	}
//
//	return tmp;
//}
//int main()
//{
//	char src[] = "And I am handsome!";
//	char dest[50] ="You are so cute!";
//	char*ret=my_strcat(dest, src);
//	puts(ret);
//	return 0;
//}


////模拟strcmp函数
//#include <assert.h>
//int my_strcmp(const char* str1, const char* str2)
//{
//	assert(str1 && str2);
//	while (*str1 == *str2)
//	{
//		if (*str1 == '\0')
//		{
//			return 0;
//		}
//		str1++;
//		str2++;
//	}
//	return *str1 - *str2;//使用ASCII码值比较
//}
//int main()
//{
//	char str1[] = "abcq";
//	char str2[] = "abcdef";
//	int ret = my_strcmp(str1, str2);
//	printf("%d\n", ret);
//	return 0;
//}


////使用strncpy函数
//#include <string.h>
//int main()
//{
//	char str1[] = "Sam";
//	char bak[20] = "xxxxxxxxxxxx";
//	printf("%s\n",strncpy(bak, str1, 10 * sizeof(char)));
//	return 0;
//}


////使用strncat函数
//#include <string.h>
//int main ()
//{
//	 char str1[20];
//	 char str2[20];
//	 strcpy (str1,"To be ");
//	 strcpy (str2,"or not");
//	 strncat (str1, str2,10);
//	 printf("%s\n", str1);
//	 return 0;
//}

////使用strncmp函数
//#include <string.h>
//int main()
//{
//	char str[][5] = { "R2D2" , "C3PO" , "R2A6" };
//	int n;
//	puts("Looking for R2 astromech droids...");
//	for (n = 0; n < 3; n++)
//	{
//		if (strncmp(str[n], "R2xx", 2) == 0)
//		{
//			printf("found %s\n", str[n]);
//		}
//	}
//		
//	return 0;
//}

////使用strtok函数
//#include <string.h>
//int main()
//{
//	char arr[] = "192.168.6.111";
//	char buf[20] = { 0 };
//	//备份源
//	strcpy(buf, arr);
//	char sep[] = ".";//分隔符集合
//	char* ret = NULL;//接受strtok返回值
//	for (ret = strtok(buf, sep); ret != '\0'; ret = strtok(NULL, sep))
//	{
//		printf("%s\n", ret);
//	}
//	return 0;
//}




////使用strstr函数
//#include <string.h>
//int main()
//{
//	//测试例一： 父字符串："abbbcdef"，子字符串："bbc"（多次匹配）
//	//测试例二： 父字符串："abcdefabcdef"，子字符串："cdef"(一次能够找到)
//	char str1[] = "abbbcdef";
//	char* p = "bbc";
//	char* ret = strstr(str1, p);
//	if (ret != NULL)
//	{
//		printf("找到了\n");
//		printf("ret = %s\n", ret);
//	}
//	else
//	{
//		printf("没找到\n");
//	}
//	return 0;
//}



////模拟strstr函数
//#include <assert.h>
//#include <string.h>
//const char* my_strstr(const char* str1, const char* str2)
//{
//	assert(str1 && str2);//拦截空指针解引用
//	if (*str2 == '\0')//子字符串为空
//	{
//		return str1;//直接返回父字符串
//	}
//	//使用备份源
//	const char* s1 = NULL;
//	const char* s2 = NULL;
//	const char* cur = str1;//记录当前匹配成功的位置
//	
//	//计算父字符串长度
//	int leng1 = strlen(str1);
//	//计算子字符串长度
//	int leng2 = strlen(str2);
//	if (leng1 < leng2)
//		return NULL;
//
//	while (*cur != '\0')
//	{
//		s1=cur;//备份源更改指向
//		s2=str2;//备份源更改指向
//		while (*s1!='\0' && *s2!='\0' && *s1 == *s2)
//		{
//			s1++;
//			s2++;
//		}
//		if(*s2=='\0')
//			return cur;
//		cur++;
//	}
//	//没匹配成功
//	return NULL;
//}
//int main()
//{
//	//测试例一： 父字符串："abbbcdef"，子字符串："bbc"（多次匹配）	
//	//测试例二： 父字符串："abcdefabcdef"，子字符串："cdef"(一次能够找到)
//	char str1[] = "abbbcdef";
//	char* p = "bbc";
//	const char* ret = my_strstr(str1, p);
//	if (ret != NULL)
//	{
//        printf("找到了\n");
//		printf("ret = %s\n", ret);
//	}
//	else {
//		printf("没找到\n");
//	}
//	return 0;
//}



////strerror函数
//#include <string.h>
//int main()
//{
//	int i = 0;
//	for (i = 0; i <= 140; i++)//错误码信息0~140
//	{
//		char* error = strerror(i);//获取错误信息地址
//		// 检查错误信息是否包含"Unknown error"，若否则打印
//		if (strstr(error, "Unknown error") == NULL)
//		{
//			printf("%d:%s\n",i, error);
//		}
//		
//	}
//	return 0;
//}



////错误示范：strerror函数无法给出自定义函数的错误码信息地址
//#include <string.h>
//#include <errno.h>
//int Mul(int a, int b)
//{
//	int c = 0;
//	c = a + b;
//	if (c)
//		printf("%s\n",strerror(errno));
//	return c;
//}
//int main()
//{
//	int a = 2, b = 4;
//	Mul(a, b);
//	return 0;
//}


//////goto语句
//int main()
//{
//	int a = 10, b = 20;
//end:
//	for (int i = 0; i < 5; i++)
//	{
//		printf("%d\n", a + b);
//	}
//	goto end;
//	return 0;
//}





////求数组中的众数
//int majorityElement(int* nums, int numsSize)
//{
//	int flag = 0;//夺旗者
//	int soldier = 0;//军阀
//	int i = 0;
//	while (i < numsSize)
//	{
//		if (flag==nums[i])//相同阵营的军阀
//		{
//			soldier++;
//			i++;
//		}
//		else {
//			//不同阵营的军阀
//			//若军阀人数为0，夺旗
//			if (soldier == 0)
//			{
//				flag = nums[i];
//				soldier++;
//				i++;
//			}
//			else {
//                soldier --;
//				i++;
//			}
//		}
//	}
//	return flag;
//}
//int main()
//{
//	int nums[] = {6,5,5};
//	int n= sizeof(nums) / sizeof(nums[0]);
//	int mul_num=majorityElement(nums, n);
//	printf("此数组的众数为:%d\n", mul_num);
//	return 0;
//}





////perror函数
//#include <string.h>
//#include <errno.h>
//int main()
//{
//	FILE* pf= fopen("test.txt", "r");
//	if (pf == NULL)
//	{
//		printf("打开文件失败，原因是：%s\n", strerror(errno));
//		perror("打开文件失败，原因是：");
//		return 1;
//	}
//	else {
//		printf("文件打开成功\n");
//		fclose(pf);
//		pf = NULL;
//	}
//	return 0;
//}


//int main()
//{
//	float a = 0xa.1fp10;
//	printf("%f\n", a);//以浮点数形式输出
//	printf("%e\n", a);//以科学计数法形式输出
//	return 0;
//}



////浮点数下溢
//#include <float.h>
//
//int main() {
//	float x = FLT_MIN;  // float的最小正规格化数（约1.2e-38）
//	x /= 1e10f;         // 结果小于FLT_MIN，触发下溢
//	printf("x = %e\n", x);  // 输出可能为非规格化数（如1.0e-48）或0
//	return 0;
//}


////浮点数上溢
//#include <float.h>
//
//int main() {
//	float x = FLT_MAX;  // float的最大有限值（约3.4e38）
//	x *= 2.0f;          // 上溢，x变为无穷大
//	printf("x = %f\n", x);  // 输出：x = inf
//	return 0;
//}



////实现找出数组中只出现一次的数字。
//int main()
//{
//	int nums[] = { 1,2 ,3 ,4 ,5 ,1 ,2 ,3 ,4 };
//	int seed = sizeof(nums) / sizeof(nums[0]);
//	int ret = 0;
//	for (int i = 0; i < seed; i++)
//	{
//		ret ^= nums[i];// 0^a=a  a ^ a = 0
//	}
//	printf("单身狗数字为：%d\n",ret);
//	return 0;
//}


////交换两个变量（不创建临时变量）
//int main()
//{
//	int a, b;
//	a = 3, b = 5;
//	printf("交换前:a=%d b=%d\n", a, b);
//	a = a ^ b;//a先存储a^b
//	b= a ^ b;//b=a^b^b=a;连续异或运算消除的是重复的数
//	a = b^a;//a=a^b^a=b;
//	printf("交换后:a=%d b=%d\n", a, b);
//	return 0;
//}



////统计二进制中1的个数
//int Count_bin(int num)
//{
//	int count = 0;
//	while (num)
//	{
//		count++;
//		num = num & (num - 1);//消除二进制中最后一个1
//	}
//	return count;
//}
//int main()
//{
//	int num = 0;
//	printf("请输入想要计算的数的二进制中1的个数:");
//	scanf("%d", &num);
//	int count=Count_bin(num);
//	printf("二进制中1的个数为：%d\n", count);
//	return 0;
//}




////获取一个整数二进制序列中所有的偶数位和奇数位，分别打印出二进制序列
//// 
////此代码能处理负整数和正整数的二进制序列
//void print_odd_bin(num)
//{
//	// 32 位整数，偶数位共 16 位，从最高位奇数位开始处理
//	printf("奇数序列为:\n");
//	for (int i = 31; i >= 1; i -= 2)
//	{
//		// 提取当前奇数位
//		int bit = (num >> i) & 1;
//		printf("%d", bit);
//	}
//	printf("\n");
//}
//void print_even_bin(num)
//{
//	// 32 位整数，偶数位共 16 位，从最高位偶数位开始处理
//	printf("偶数序列为:\n");
//	for (int i = 30; i >= 0; i -= 2)
//	{
//		// 提取当前偶数位
//		int bit = (num >> i) & 1;
//		printf("%d", bit);
//	}
//	printf("\n");
//}
//int main()
//{
//	int num = 0;
//	printf("请输入一个整数:>");
//	scanf("%d", &num);
//	print_odd_bin(num);// 函数用于打印整数二进制序列的奇数位
//	print_even_bin(num);// 函数用于打印整数二进制序列的偶数位
//	return 0;
//}




////求两个数二进制中不同位的个数
//int differ_bin(int m, int n)
//{
//	int count = 0;
//	int bin = m ^ n;//计算有多少位不同
//	while (bin)
//	{
//		bin = bin & (bin - 1);//有多少个二进制1的存在,每次运算一次就消去最右边的1
//		count++;
//	}
//	return count;
//}
//int main()
//{
//	int m = 0, n = 0;
//	printf("请输入两个数:>");
//	scanf("%d %d", &m, &n);
//	int cou=differ_bin(m, n);
//	printf("两个操作数二进制中不同位的个数为：%d\n", cou);
//	return 0;
//}


////预定义符号
//int main()
//{
//	printf("file:%s\nline:%d\n", __FILE__, __LINE__);
//	printf("date=%s\ntime=%s\n", __DATE__, __TIME__);
//	printf("%d\n", __STDC__);//表示VS编译器不完全支持C99标准
//	return 0;
//}


////错误示范宏定义
//#define MAX 1000;
//int main(void)
//{
//	int condition = 0;
//	int max = 0;
//	printf("请为condition赋值:\n");
//	scanf("%d", &condition);
//	if (condition)
//		max = MAX;
//	else
//		max = 0;
//
//	return 0;
//}



////#define 定义宏
//#define SQUARE(x) x*x
//int main()
//{
//	int a = 5;
//	printf("a=%d\n", SQUARE(a));
//	printf("a=%d\n", SQUARE(a+1));//宏定义不会进行运算，只是简单的文本替换
//	//相当于 5+1*5+1=5+5+1=11
//	//所以结果为25+1*1=26
//	return 0;
//}

////修改上序的代码
//#define SQUARE(x) (x)*(x)
//int main()
//{
//	int a = 5;
//	printf("a=%d\n", SQUARE(a));
//	printf("a=%d\n", SQUARE(a + 1));//修改后：相当于(5+1)*(5+1)=6*6=36
//	return 0;
//}


////调试宏
////'\'是续航符，可以连接两行代码,但\后面不能跟空格，前面可以，理解为换行符
//#define DEbug_print printf("file:%s\nline:%d\ndate：%s\ntime：%s\n",\
//					 __FILE__, __LINE__,                            \
//					__DATE__,__TIME__)
//#define DEBUG_pr for(int i=0;i<10;i++)\
//printf("hello world\n")
//
////宏定义去写Switch语句
//#define  CASE break;case
//int main()
//{
//	int a = 0;
//	printf("请选择case语句的分支是:>\n");
//	scanf("%d", &a);
//	DEbug_print;
//    DEBUG_pr;
//	switch (a)
//	{
//	case 1:printf("case 1\n");
//	CASE 2:printf("case 2\n");
//    CASE 3:printf("case 3\n");
//	default:
//		break;
//	}
//	return 0;
//}





////写一个宏，计算两个数的最大值
//#define MAX(a,b) ((a)>(b)?(a):(b))
//int main()
//{
//	int a = 10;
//	int b = 20;
//	int max = MAX(a++, b++);//宏定义不会进行运算，只是简单的文本替换
//	//宏替换的结果为 ((a++)>(b++)?(a++):(b++))
//	printf("最大值为:%d\n", max);//10>20?10:20,所以max=b++,即max=21
//	printf("但a和b的值都会被修改\n");
//    printf("a=%d\n", a);//先开始a=10，然后a++,a=11
//	printf("b=%d\n", b);//先开始b=20,然后b++,b=21,进行判断后又要b++，所以b=22
//	return 0;
//}






////逻辑取反操作符
//int main()
//{
//	int num = 4;
//	if (!(num % 2)) {  // 正确：判断 num 是否为偶数
//		printf("偶数\n");
//	}
//	// 错误示例：!num % 2 等价于 (!num) % 2，可能不符合预期
//	return 0;
//}


////负数取反
//int main()
//{
//	int num = -6;
//	printf("%d\n", ~num+1);
//	return 0;
//}




////截断现象
//int main()
//{
//	int a = 300;        // int类型（假设4字节，范围-2^31~2^31-1）
//	char b = a;         // char类型（1字节，范围-128~127）
//	printf("%d", b);    // 输出44（300的二进制后8位是00101100，即44）
//	return 0;
//}


//#include <limits.h>
//int main()
//{
//	// 测试截断
//	int num = 0x1234;
//	char c = num; // c = 0x34（假设小端）
//	printf("%x\n", c);//%x打印十六进制数字
//
//	// 测试溢出
//	unsigned int u = UINT_MAX;
//	u += 1;       // u = 0
//	printf("%u\n", u);
//
//	int i = INT_MAX;
//	i += 1;       // UB！可能输出-INT_MAX-1或崩溃
//	printf("%d\n", i);
//	return 0;
//}


////测试size_t类型值范围（测试是32位机器还是64位机器）
//#include <stdio.h>
//#include <stdint.h>
//
//int main() {
//	size_t s = 100;
//	printf("Size: %zu, Max: %zu\n", s, SIZE_MAX);
//	printf("Sizeof(size_t): %zu bytes\n", sizeof(s));
//	return 0;
//}
//}





////PIO6 单组_一维数组
////变长数组
//int main() {
//	int n;
//	scanf("%d", &n);
//	int a[n];
//	long long sum = 0;
//	for (int i = 0; i < n; i++) {
//		scanf("%d", a + i);
//		sum += *(a + i);
//	}
//	printf("%lld", sum);
//	return 0;
//}



////PIO9 多组_二维数组_T组形式
//int main() {
//	long long int t = 0;
//	scanf("%lld", &t);
//	long long int a, b;
//	long long int sum, j, k;
//	for (int i = 0; i < t; i++)
//	{
//		scanf("%lld %lld", &a, &b);
//		long long int n, m;
//		long long int a[n][m];
//
//		for (j = 0; j < n; j++) {
//			for (k = 0; k < m; k++)
//			{
//				scanf("%lld", &a[n][m]);
//				sum += a[n][m];
//			}
//
//		}
//		printf("%lld\n", sum);
//	}
//
//
//
//	return 0;
//}



////PIO11 多组_字符串_T组形式
//#include <stdio.h>
//
//int main() {
//	long int num = 0; 
//	long int t = 0; 
//	char a[100];
//	scanf("%ld", &t);//输入多少用例
//
//	while (t)//测试用例
//	{
//		scanf("%ld", &num);
//		getchar();//吃换行符
//		for (long int i = 0; i < num; i++)
//		{
//			scanf("%c", &a[i]);//顺序输入字符串
//		}
//		for (long int j = num - 1; j >= 0; j--)
//		{
//			printf("%c", a[j]);//逆序打印字符串
//		}
//		printf("\n");
//		t--;
//	}
//	return 0;
//}




////PIO12 单组_二维字符数组
//int main()
//{
//	char a[100][100];
//	for (int i = 0; i < 3; i++)
//	{
//		scanf("%s", a[i]);//二维数组当做一维数组的数组，以字符串的形式输入，给出每行地址输入即可
//	}
//	for (int i = 0; i < 3; i++)
//	{
//		for (int j = 0; j < 4; j++)
//		{
//			printf("%c", a[i][j]);
//		}
//		printf("\n");
//	}
//	
//	return 0;
//}

////补充前置导0
//int main()
//{
//	long long int n = 0;
//	scanf("%lld", &n);
//	printf("%09lld", n);//%[m]d:限制输出位数总长
//	return 0;
//}

////冒泡排序排列在前，不然二分查找会出问题
//void bubble_sort(int* arr, int seed)
//{
// 
//    int i, j;
//    for (i = 0; i < seed - 1; i++)//趟数
//    {
//        int flag = 1;//标志位
//        for (j = 0; j < seed - 1 - i; j++)//交换的次数
//        {
//            if (arr[j] > arr[j + 1])
//            {
//                flag = 0;//改变标志位
//                int tmp = *(arr+j);
//                arr[j] = *(arr+j+1);
//                arr[j + 1] = tmp;
//            }
//           
//        }
//        if (flag == 1)//一开始就是有序的就不需要进入开销
//        {
//            break;
//        }
//    }
//}
//
////二分查找的时间复杂度为O(logN)
//int binarySearch(int arr[], int n, int target) {
//    int left = 0;
//    int right = n - 1;
//
//    while (left <= right) {
//        // 防止整数溢出的写法
//        int mid = left + (right - left) / 2;
//
//        if (arr[mid] == target) {
//            return mid;  // 找到目标，返回索引
//        }
//        else if (arr[mid] < target) {
//            left = mid + 1;  // 目标在右半部分
//        }
//        else {
//            right = mid - 1;  // 目标在左半部分
//        }
//    }
//
//    return -1;  // 未找到目标
//}
//
////遍历数组
//void Print(int* arr, int seed)
//{
//    for (int i = 0; i < seed; i++)
//    {
//        printf("%d ", *(arr + i));
//    }
//    printf("\n");
//}
//
////二分查找的前提必须保证数组是有序的！
//int main() {
// /*   int arr[] = { 1, 3, 5, 7, 9, 11, 13, 15 };*/
//    int arr[] = { 3,2,5,4,7,8,10,9,1,6 };//乱序的数组
//    int n = sizeof(arr) / sizeof(arr[0]);
//    int target = 6;//查找的数字
//    printf("最初始的数组:>\n");
//    Print(arr, n);
//    bubble_sort(arr, n);
//    printf("经过冒泡后的数组:>\n");
//    Print(arr, n);
//    int result = binarySearch(arr, n, target);
//
//    if (result != -1) {
//        printf("元素 %d 的索引是 %d\n", target, result);
//    }
//    else {
//        printf("元素 %d 不在数组中\n", target);
//    }
//
//    return 0;
//}





//#include <math.h>
//
//// 判断是否为素数的辅助函数
//int is_prime(int n) {
//    if (n <= 1) return 0;       // 小于等于1的不是素数
//    if (n == 2 || n == 3) return 1; // 2和3是素数
//    if (n % 2 == 0) return 0;   // 能被2整除的不是素数
//    for (int i = 3; i <= sqrt(n); i += 2) { // 检查奇数因子
//        if (n % i == 0) 
//            return 0;
//    }
//    return 1;//否则为素数
//}
//
//void fun(int m, int xx[], int* k) {
//    *k = 0; // 初始化非素数个数
//    for (int num = 2; num < m; num++) { // 遍历2到m-1
//        if (!is_prime(num)) { // 如果是非素数
//            xx[*k] = num;    // 存入数组
//            (*k)++;          // 计数器递增
//        }
//    }
//}
//
////编写函数fun，其功能是：将所有大于1小于整数m的非素数存入xx所指数组中，非素数的个数通过k返回。
//// 例如：若输入17，则应输出4  6  8  9  10  12  14  15  16。
//int main() {
//    int m = 17;
//    int non_primes[100]; // 假设数组足够大
//    int count;
//
//    fun(m, non_primes, &count);
//+
//    printf("非素数个数: %d\n", count);
//    printf("非素数列表: ");
//    for (int i = 0; i < count; i++) {
//        printf("%d ", non_primes[i]);
//    }
//    return 0;
//}







////复习##的使用
////使用预处理指令套模板生成泛型函数
//#define GENERATE_MAX(type) \
//type type##_max(type a, type b) \
//{ \
//return a>b?a:b;\
//}
//
////产生整形的max函数
//GENERATE_MAX(int)//拆开预处理后会直接在此程序后展开为相应的模板函数
////产生浮点型的max函数
//GENERATE_MAX(float)//这也是如此
//
//int main()
//{
//	int a = 10, b = 20;
//	int r = int_max(a, b);
//	printf("int_max = %d\n", r);
//	float x= 10.5, y = 20.5;
//	float r2=float_max(x, y);
//    printf("float_max = %f\n", r2);
//	return 0;
//}



////复习#的使用
//#define Print(type,format) \
//printf("The num " #type " is " format "\n",type);
//
//int main()
//{
//	int a = 10;
//	Print(a, "%d");
//	printf("The num a is %d\n", a);
//	float b = 20.9f;
//	printf("The num b is %f\n", b);
//	return 0;
//}


//#define MAX 10
//
//int main()
//{
//	int arr[MAX] = {0};
//#undef MAX
//	int arr1[MAX] = { 0 };
//	return 0;
//}


#if 0
int Bin_Search(int* arr, int n, int target)
{
	int left = 0;
	int right = n - 1;
	while (left <= right)
	{
		int mid = (left + right) / 2;
		if (arr[mid] == target)
		{
			return mid;
		}
		else if (arr[mid] < target)
		{
			right = mid - 1;
		}
		else {
			left = mid + 1;
			
		}
	}
	//不存在下标，返回-1
	if (left > right)
	{
		return -1;
	}
}


#define n 10
//#undef n
int main()
{
	//int n=0;
	//printf("请输入数组总长度:>\n");
	//scanf("%d", &n);
	//int a[n];//C99
	int a[n];
	printf("请循环输入数组各值:>\n");
	for (int i = 0; i < n; i++)
	{
		scanf("%d", &a[i]);//用户自定义输入
	}
	int target = 0;
	printf("用户自定义输入搜索值为:>\n");
	scanf("%d", &target);
	
	//二分查找
	int ret=Bin_Search(a, n, target);
	printf("找到了下标为:%d", ret);
	

	return 0;
}
#endif


#if 0
//测试条件编译
#define EXECUTE //定义开关
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		arr[i] = i + 1;//赋值为1~10
#ifdef  EXECUTE
        printf("%d ", arr[i]);
#endif //开关控制器，如果EXECUTE被定义，则执行printf

#ifndef  EXECUTE
		printf("%d ", arr[i]);//否则执行printf
#endif // !

	}
	return 0;
}
#endif





#if 0
//复习将二维数组倒置
int main()
{
	int a[2][3] = { 1,2,3,4,5,6 };
	int i = 0, j = 0;
	for (i = 0; i < 2; i++)
	{
		for (j = 0; j < 3; j++)
		{
			printf("%d ", a[i][j]);
		}
		printf("\n");
	}
	printf("\n");
	//倒置
	for (i = 0; i < 3; i++)
	{
		for (j = 0; j < 2; j++)
		{
			printf("%d ", a[j][i]);
		}
		printf("\n");
	}
	return 0;
}

#endif


#if 0
//杨辉三角
#define row 5
#define col 5
int main()
{
	int arr[row][col] = { 0 };
	//填充
	for (int i = 0; i < row; i++)
	{
		//每一行的第一个和最后一个都是1
		arr[i][0] = 1;
		arr[i][i] = 1;
		for (int j = 1; j < i; j++)
		{
			arr[i][j] = arr[i - 1][j - 1] + arr[i - 1][j];
			//中间的每个元素由上一行的两个数相加。
		}
	}
	//格式化输出
	for (int i = 0; i < row; i++)
	{
		// 打印前导空格实现居中对齐
		for (int space = 0; space < row- i - 1; space++) {
			printf("   "); // 每个数字占3字符宽，空格对应
		}
		for (int j = 0; j <= i; j++)
		{
			printf("%-6d", arr[i][j]);
		}
		printf("\n");
	}
	return 0;
}
#endif




#if 0
#include <string.h>
int main()
{
	char str[10] = {0};
	printf("请输入：>\n");
	fgets(str,sizeof(str),stdin);
	puts(str);

	return 0;
}

#endif


#if 0
#define row 10
#define col 10
int main()
{
	int arr[row][col];
	//赋值
	int i, j;
	for (i = 0; i < row; i++)
	{
		//最初始的1、2行
		arr[i][0] = 1;
		arr[i][i] = 1;
		//第三行开始有变化
		for (j = 1; j < i; j++)//当i为2时才能进来，也就是第二行
		{
			arr[i][j] = arr[i - 1][j - 1] + arr[i - 1][j];
		}
		
	}
	//打印
	for (i = 0; i < row; i++)
	{
		for (j = 0; j < i + 1; j++)
		{
			printf("%-4d", arr[i][j]);
		}
		printf("\n");
	}
	return 0;
}
#endif



#if 0
#include <string.h>
int main()
{
	char a[1000] = { 0 };
	int i = 0;
	for (i = 0; i < 1000; i++)
	{
		a[i] = -1 - i;
	}
	printf("%zd", strlen(a));//返回无符号整形

	return 0;
}
#endif

//大小端
#if 0
int main()
{
	int num = 1;
	if (*((char*)&num) == 1)
	{
		printf("小端存储\n");
	}
	else
		printf("大端存储\n");
	return 0;
}
#endif


////atio函数是将字符串转换为整数
////模拟实现atoi函数#include <stdio.h>
//#include <limits.h> // 用于INT_MAX和INT_MIN
//
//int myAtoi(const char* str) {
//	if (str == NULL) {
//		return 0;
//	}
//
//	// 跳过前导空格
//	while (*str == ' ') {
//		str++;
//	}
//
//	// 检查符号
//	int sign = 1;
//	if (*str == '+') {
//		str++;
//	}
//	else if (*str == '-') {
//		sign = -1;
//		str++;
//	}
//
//	// 处理数字部分
//	long result = 0;
//	while (*str >= '0' && *str <= '9') {
//		result = result * 10 + (*str - '0');
//		str++;
//
//		// 检查是否超出int的范围
//		if (result * sign > INT_MAX) {
//			return INT_MAX;
//		}
//		if (result * sign < INT_MIN) {
//			return INT_MIN;
//		}
//	}
//	//可能数值位为字母部分
//	while (*str >= 'a' && *str <= 'z')
//	{
//		result = result * 10 + (*str - 'a');
//		str++;
//
//		// 检查是否超出int的范围
//		if (result * sign > INT_MAX) {
//			return INT_MAX;
//		}
//		if (result * sign < INT_MIN) {
//			return INT_MIN;
//		}
//	}
//	while (*str >= 'A' && *str <= 'Z')
//	{
//		result = result * 10 + (*str - 'A');
//		str++;
//
//		// 检查是否超出int的范围
//		if (result * sign > INT_MAX) {
//			return INT_MAX;
//		}
//		if (result * sign < INT_MIN) {
//			return INT_MIN;
//		}
//	}
//	return (int)(result * sign);
//}
//
//int main() {
//	const char* str = "   -1234567890";
//	//const char* str = "   jingyu";
//	int num = myAtoi(str);
//	printf("Converted integer: %d\n", num);
//	return 0;
//}



//#if 1
////编写函数fun，其功能是：将所有大于1小于整数num的非素数存入xx所指数组中，非素数的个数通过k返回。
//// 例如：若输入17，则应输出4  6  8  9  10  12  14  15  16。
//// 判断一个数是否为素数
//int isPrime(int n) {
//	if (n <= 1) return 0;
//	//i*i过滤掉了2和3.2和3本身就是素数，1既不是素数也不是合数
//	for (int i = 2; i * i <= n; i++) {
//		if (n % i == 0) return 0;
//	}
//	return 1;
//}
//
//// 将所有大于1小于整数num的非素数存入xx所指数组中，非素数的个数通过k返回
//void fun(int num, int xx[], int* k) {
//	*k = 0;
//	for (int i = 2; i < num; i++) {	
//		if (!isPrime(i)) 
//		{
//			xx[(*k)++] = i;
//		}
//	}
//}
//
//int main() {
//	int num = 17;
//	int xx[100];
//	int k;
//	fun(num, xx, &k);
//	printf("大于1小于%d的非素数有：", num);
//	for (int i = 0; i < k; i++) {
//		printf("%d ", xx[i]);
//	}
//	printf("\n非素数的个数为：%d\n", k);
//	return 0;
//}
//#endif



////指定数组初始化
//#if 1
//#define N 10
//int main()
//{
//	int arr[N] = { [2] = 5,[7] = 9,[9] = 10 };
//	//括号中的数字是下标，也称为指示符 ，指示符必须是常量表达式。
//	for (int i = 0; i < N; i++)
//	{
//		printf("%d ", *(arr + i));
//	}
//	return 0;
//}
//#endif



//判断是否出现冗余数字/此数字是否为单身狗
#if  0
#include <stdbool.h>
int main()
{
	bool digit_seen[10] = { false };
	int digit = 0;
	long num = 0;
	printf("Please input a number:\n");
	scanf("%d", &num);
	while (num)
	{
		digit = num % 10;//取出个位数
		if (digit_seen[digit])//所判断的下标为0~9
			break;
		digit_seen[digit] = true;//如果已经判断了这个数字，改标签为true
		num /= 10;//再把个位数过滤掉
	}
	if (num > 0)
	{
		printf("此数字属于冗余数字\n");
	}
	else
	{
		printf("此数字不属于冗余数字\n");
	}
	return 0;
}
#endif



#if 0
//全局变量的应用场景

//一维数组放10个学生成绩，写一个函数求出平均分、最高分、最低分，并返回给主函数。
float Max=0.0f,Min=0.0f;

float count_score(float* score, int seed)
{
	//擂台赛
	Max = Min = score[0];//修改初始值
	float sum = 0.0f;
	float ave = 0.0f;
	for (int i = 0; i < seed; i++)
	{
		if (score[i] > Max)
		{
			Max = score[i];//更新最大值，所以在主函数里面的Max也会被更改
		}
		if (score[i] < Min)
		{
            Min = score[i];//更新最小值，所以在主函数里面的Min也会被更改
		}
		sum+= score[i];//累加分数
	}
	ave = sum / seed;//平均值
	return ave;//函数只能返回一个值，所以只能返回平均值
}
int main()
{
	float score[10] = { 0 };
	float average = 0.0f;
	int i = 0;
	int seed = sizeof(score) / sizeof(score[0]);
	printf("请输入10个学生的成绩：\n");
	for (i = 0; i < seed; i++)
	{
		scanf("%f", &score[i]);
	}
	average= count_score(score,seed);
	printf("学生的平均分为:%f ,最高分为:%f ,最低分为:%f \n", average, Max, Min);
	return 0;
}
//注解：全局变量在函数中是可以直接使用的，但是全局变量在函数中修改，可能会对其他函数产生影响，所以使用全局变量时，要慎重
#endif


#if 0
//利用静态局部变量实现“多少数到多少数的阶乘”
int total_mul(int i)
{
	static int f = 1;
	return f *= i;
}
int main()
{
	int i = 1;//阶乘必须从1开始，不能从0开始
	int num = 0;
	//int num2 = 1;
	printf("请输入想求多少数到多少的阶乘结果:>");
	scanf("%d", &num);
	for (i = 1; i <= num; i++)
	{
		printf("%d!=%d\n", i,total_mul(i));
		//num2=total_mul(i);
	}
	//printf("%d!=%d\n", i-1, num2);//求多少数字的阶乘结果
	return 0;
}
#endif


#if 0
//输入两个学生的学号、姓名、成绩，输出成绩较高的学生学号、姓名、成绩
typedef struct Student {
	int num;
	float score;
	char name[10];
}Student;
int main()
{
	Student student1, student2;
	printf("请分别为两位同学给出学号、命名以及分数：>\n");
	scanf("%d%s%f", &student1.num, student1.name, &student1.score);//数组名就是地址
	getchar();//吃换行符
	scanf("%d%s%f", &student2.num, student2.name, &student2.score);
	getchar();//吃换行符
	printf("The higher score student is:>\n");
	if (student1.score > student2.score)
		printf("%d %s %.2f\n", student1.num, student1.name, student1.score);
	else if(student1.score<student2.score)
		printf("%d %s %.2f\n", student2.num, student2.name, student2.score);
	else {
		printf("这两同学成绩相同,他们分别是:>\n");
		//下面是前导0的写法
		printf("%0d %s %.2f\n", student1.num, student1.name, student1.score);
		printf("%0d %s %.2f\n", student2.num, student2.name, student2.score);
	}
	return 0;
}
#endif


//递归：逆序打印该数的每一位
#if 0
void Print(num)
{
	if (num > 0)//过滤个位以上的
	{
		printf("%ld", num % 10);
		Print(num / 10);
	}
}
int main()
{
	long num = 0;
	printf("请输入你想要顺序打印的数字：>\n");
	scanf("%ld", &num);
	Print(num);
	return 0;
}
#endif



#if 0
//实现字母的大小写转换。多组输入输出
int main()
{
	int ch = 0;
	while ((ch = getchar()) != EOF)
	{
		printf("%c\n", (ch + 32));
		getchar();//吃回车
	}
	return 0;
}
#endif


//学生成绩打印四舍五入
#if 0
#include <math.h>
int main() { 
	long  a;
	float b=0.0f, c=0.0f, d=0.0f;
	scanf("%ld;%f,%f,%f", &a, &b, &c, &d); 
	b =roundf(b * 100.0f) / 100.0f;
	c = roundf(c * 100.0f) / 100.0f;
	d = roundf(d * 100.0f) / 100.0f;
	printf("The each subject score of No. %ld is %.2f, %.2f, %.2f.", a, b, c, d);
	return 0;
}
#endif


#if 0
//认识小端存储
int main()
{
	int a = 0x11223344;//十六进制数字
	return 0;
}
#endif


#if 0
//判断存储形式
//方法一：采用解引用方式
int check_memory()
{
	int check = 1;
	//取出check的最低位
	return (*(char*)&check);
}
int main()
{
	int num = check_memory();
	if(num==1)
		printf("小端存储\n");
	else {
        printf("大端存储\n");
	}
	return 0;
}
#endif


#if 0
union Union {
	int i;
	char c;
}un1;
//共用体的大小与成员中占用空间最大的成员大小一致
int main()
{
	un1.i = 1;//将1赋值给i，因为i是int类型，所以会占用4个字节
	printf("%zd\n", sizeof(un1));//测试得出共用体的大小为4
	if (un1.c == 1)
	{
		printf("小端存储\n");
	}
	else {
		printf("大端存储\n");
	}
	return 0;
}
#endif




#if 0
//浮点数存储
int main()
{
	/*printf("float类型所占字节个数为:%zd Byte\n"\
	, sizeof(float));*/

    printf("double类型所占字节个数为:%zd Byte\n"\
	, sizeof(double));
	return 0;
}
#endif



#if 0
//BC29 2的n次方计算

//通过移位运算（<<）实现2的n次方的计算。
int main()
{
	int num = 0;
	while (scanf("%d", &num) != EOF)
	{
		printf("%d\n", 1 << num);
	}

	return 0;
}
#endif


#if 0
//BC15 按照格式输入并交换输出
//题目：交换两个变量的值（难度提升：如果不创建第三个变量来实现变量交换）
int main()
{
	int a = 0, b = 0;
	scanf("a=%d,b=%d", &a, &b);
	//a^a=0,a^0=a
	//不创建第三个变量进行交换
	a = a ^ b;//先更新a的值
	b = a ^ b;
	a = a ^ b;
	printf("a=%d,b=%d", a, b);
	return 0;
	return 0;
}
#endif



#if 0
//BC19 反向输出一个四位数
int main()
{
	//如果四位数有0也可以反向输出
	int reversed = 0;
	scanf("%d", &reversed);
	if (reversed == 0)
	{
		printf("%0d", reversed % 10);
		reversed /= 10;
	}
	while (reversed > 0)
	{
		printf("%d",reversed % 10);
		reversed /= 10;
	}
	return 0;
}
#endif


#if 0
//特殊数字表示测试
int main()
{
	//int test = 0765;
	/*int test2 = 0b1010;
	printf("%d\n", test2);*/
	//printf("%d\n", test);
	int test3 = 0x48;
	printf("%d\n", test3);
	return 0;
}
#endif


#if 0
#include <stddef.h>
//复习offsetof宏，偏移量
typedef struct STU{
	int i;
	char ch;
	float f;
}STU;
int main()
{
	STU s = { 0 };
	printf("The offsetof of i=%zd\n", offsetof(STU , i));
	printf("The offsetof of ch=%zd\n", offsetof(STU , ch));
	printf("The offsetof of f=%zd\n", offsetof(STU , f));
	return 0;
}
#endif




#if 0
//写一个宏，将一个整数的二进制位的奇数位和偶数位交换
//位运算想起（& | ^ << >>）,这些运算符的操作数只能是整数
#define Swap_Odd_And_Even(num) (((num)&0xaaaaaaaa)>>1)|(((num)&0x55555555)<<1)
int main()
{
	int num = 0;
	scanf("%d", &num);
	int ret=Swap_Odd_And_Even(num);
	printf("原数%d的二进制位奇偶位调换后的结果为:%d\n", num, ret);
	return 0;
}
#endif


#if 0
//结构体数组
struct stu
{
	int num;
	char name[10];
	int age;
};
void fun(struct stu* p)
{
	printf("%s\n", (*p).name);
	return;
}

int main()
{
	struct stu students[3] = { {9801,"zhang",20},
								{9802,"wang",19},
					{9803,"zhao",18} };
	fun(students + 1);
	return 0;
}

#endif




#if 0
//BC26 计算三角形的周长和面积
#include <math.h>
int main() {
	int a, b, c;
	float Circle = 0.0f, Surround = 0.0f, Half_Cir = 0.0f;
	printf("请输入三角形的三边长:>\n");
	scanf("%d %d %d", &a, &b, &c);
	Circle = (float)a + b + c;//周长
	Half_Cir = (float)Circle * 0.5f;//海伦公式里的半周长
	Surround = sqrtf(Half_Cir * (Half_Cir - a) * (Half_Cir - b) * (Half_Cir - c));
	//三角形面积公式
	printf("circumference=%.2f area=%.2f", Circle, Surround);
	return 0;
}
#endif



#if 0
//BC27 计算球体的体积
//考点：数学公式，浮点数计算
//注意：浮点数计算时，尽量使用float类型，因为double类型可能会出现精度丢失
//小数除法：需要在/的前面或后面加上浮点数参数才能进行小数除法，否则就是整数除法
#include <math.h>
#define pai 3.1415926
int main() {
	double r = 0.0;
	double V = 0.0f;
	scanf("%lf", &r);
	V = 4.0 / 3 * pai * pow(r, 3.0);
	printf("%.3f", V);
	return 0;
}
#endif



#if 0
//BC98 序列中删除指定数字
//描述：
//有一个整数序列（可能有重复的整数），现删除指定的某一个整数，
//输出删除指定数字之后的序列，序列中未被删除数字的前后位置没有发生改变。
//
//数据范围：序列长度和序列中的值都满足1≤n≤50
//输入描述：
//第一行输入一个整数(0≤N≤50)。
//
//第二行输入N个整数，输入用空格分隔的N个整数。
//
//第三行输入想要进行删除的一个整数。
//
//输出描述：
//输出为一行，删除指定数字之后的序列。
int main()
{
	int n = 0, repeat = 0;
	int i = 0;
	int arr[50];//处于N>=0&&N<=50范围里
	scanf("%d", &n);
	//循环赋值
	for (i = 0; i < n; i++)
	{
		scanf("%d ", &arr[i]);
	}
	//输入删除数字
	scanf("%d", &repeat);
	//遍历判断
	for (i = 0; i < n; i++)
	{
		if (arr[i] == repeat)
			continue;//判断成功就跳过此循环，不执行打印此序列数
		printf("%d ", arr[i]);
	}
	return 0;
}
#endif


#if 0
//封装函数接口来改变结构体p的值
typedef struct point 
{
	int x;
	int y;
}point;

void revisePoint(point** pp)//传地址调用
{
	//*pp为找到结构体指针p
	//进行访问结构体指针只能用箭头
	(*pp)->x = 100;
	(*pp)->y = 200;
	printf("%d %d\n", (*pp)->x, (*pp)->y);
}

int main()
{
	point p;//结构体声明
	p.x = 10;//结构体实例化
	p.y = 20;
	point* pp = &p;//结构体指针指向
	revisePoint(&pp);//传参为结构体指针
	return 0;
}
#endif





#if 0
#include <stdlib.h>
//qsort使用练习
int cmp_int(const void* x, const void* y)
{
	//升序排列
	return *((int*)x) - *((int*)y);
	//降序排列
	//return *((int*)y)- *((int*)x);
}
void Print_INT(int* arr, int seed)
{
	for (int i = 0; i < seed; i++)
	{
		printf("%d ", *(arr + i));
	}
	printf("\n");
}
void Int_Sort()
{
	int arr[] = { 0,10,3,2,1,6,7,5,8,9 };
	int seed = sizeof(arr) / sizeof(arr[0]);
	printf("排序前:>");
	Print_INT(arr, seed);
	qsort(arr, seed, sizeof(int), cmp_int);
	printf("排序后:>");
	Print_INT(arr, seed);
}
void Print_CHAR(char* arr,int seed)
{
	for (int i = 0; i < seed; i++)
	{
		printf("%c", *(arr + i));
	}
	printf("\n");
}
int cmp_char(const void* a,const void* b)
{
	//升序排列
	return (*(char*)a - *(char*)b);
	//降序排列
	return (*(char*)b - *(char*)a);
}
void Char_Sort()
{
	char arr[] = "fatal love";
	int seed = sizeof(arr) / sizeof(arr[0]);
	printf("排序前:>");
	Print_CHAR(arr, seed);
	qsort(arr, seed, sizeof(char), cmp_char);
	printf("排序后:>");
	Print_CHAR(arr, seed);
}
int main()
{
	Int_Sort();
	Char_Sort();
	return 0;
}
#endif



#if 0
//模拟qsort函数实现
#include <string.h>
struct Stu
{
	char name[20];
	int age;
};
void love_print(int* arr, int seed)
{
	for (int i = 0; i < seed; i++)
	{
		printf("%d ", *(arr + i));
	}
}
void print(struct Stu* arr, int seed)//打印结构体数据函数
{
	for (int i = 0; i < seed; i++)
	{
		printf("%s %d\n", arr->name, arr->age);
		arr++;
	}
}
void Swap(char* buff1, char* buff2, size_t size)
{
	//以每个字节为单位进行交换
	char tmp = 0;
	for (size_t i = 0;i<size; i++)
	{
		tmp = *buff1;
		*buff1 = *buff2;
		*buff2 = tmp;
		buff1++;
		buff2++;
	}
}
//用冒泡排序模拟qsort排序（形参是函数指针（回调函数））
void bubble_maker(void* base, int seed, int size, int(*cmp)(const void* p1, const void* p2))
{
	//cmp指针指向你想排序什么样的数据类型的函数
	for (int i = 0; i < seed - 1; i++)
	{
		//趟数
		for (int j = 0; j < seed - 1 - i; j++)
		{
			//元素对数
			if (cmp((char*)base + j * size, (char*)base + (j + 1) * size) > 0)//调用所需排序的函数
			{
				//交换函数
				Swap((char*)base + j * size, (char*)base + (j + 1) * size, size);
			}
		}
	}
}

int cmp_int(const void* p1, const void* p2)
{
	//想排序整形数据的函数
	return *((int*)p1) - *((int*)p2);
}
int cmp_struct(const void* p1, const void* p2)
{
	//想排序结构体名字数据的函数
	return strcmp(((struct Stu*)p1)->name, ((struct Stu*)p2)->name);
}
void test1()
{
	int arr[] = { 2,9,4,6,1,7,3,8,5,0 };
	int seed = sizeof(arr) / sizeof(arr[0]);
	printf("排序前:\n");
	love_print(arr, seed);
	bubble_maker(arr, seed, sizeof(arr[0]), cmp_int);
	printf("\n");
	printf("排序后:\n");
	love_print(arr, seed);
}
void test2()
{
	struct Stu arr[] = { {"zhangsan",20},{"lisi",30},{"wangwu",40} };
	int seed = sizeof(arr) / sizeof(arr[0]);
	printf("\n");
	printf("排序前\n");
	print(arr, seed);
	bubble_maker(arr, seed, sizeof(arr[0]), cmp_struct);
	printf("\n");
	printf("排序后\n");
	print(arr, seed);
}


int main()
{
	test1();//交换整形数据
	test2();//交换结构体数据
	return 0;
}
#endif




#if 0
//随机数复习
#include <stdlib.h>
#include <time.h>
int RANDOM()
{
	return rand() % 100 + 1;
}
int main()
{
	//time 函数获取当前时间
	//srand 函数设置随机数种子
    srand((unsigned int)time(NULL));
	//若要获取1~100的随机数
	int arr[10] = { 0 };
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", RANDOM());
	}
    
	return 0;
}
#endif


#if 0
int main()
{
	double sum = 1.0;//首项
	int deno = 2;//分母
	int flag = -1;//符号
	while (deno <= 5)
	{
		sum += flag * (1.0 / deno);
		flag = -flag;
		deno++;
	}
	printf("sum=%lf\n", sum);
	return 0;
}
#endif

#if 0
//求方程式a*x^2+b*x+c=0的根
#include <math.h>
int main()
{
	int a = 0, b = 0, c = 0;
	int judge = 0;
	
	printf("请输入想求的二元一次方程的a、b、c各值\n");
	scanf("%d%d%d", &a, &b, &c);
	judge = b * b - 4 * a * c;//判别式
	if (judge > 0)
	{
		int root1 = 0, root2 = 0;
		root1 = (-b + (int)sqrt(judge)) / 2 * a;
		root2 = (-b - (int)sqrt(judge)) / 2 * a;
		printf("此二元一次方程有两个根，分别为x1=%d,x2=%d\n", root1, root2);
	}
	else if(judge==0)
	{
		int root = 0;
		root = -b / (2 * a);
		printf("此方程只有一个根:x=%d\n", root);
	}
	else
	{
		printf("此方程无根\n");
	}
	return 0;
}
#endif


//交换数组——只需要交换对应下标的值即可
#if 0
int main()
{
	int arr1[] = { 1,2,3,4,5 };
    int arr2[] = { 6,7,8,9,10 };
	printf("交换前：\n");
	for (int i = 0; i < 5; i++)
	{
		printf("%d ", arr1[i]);
	}
    	printf("\n");
	for (int i = 0; i < 5; i++)
	{
        printf("%d ", arr2[i]);
	}
	printf("\n");
	
	//交换数组——对应下标的值进行交换
	for (int i = 0; i < 5; i++)
	{
		int tmp = arr1[i];
		arr1[i] = arr2[i];
        arr2[i] = tmp;
	}
	printf("交换后：\n");
	for (int i = 0; i < 5; i++)
	{
		printf("%d ", arr1[i]);
	}
	printf("\n");
	for (int i = 0; i < 5; i++)
	{
		printf("%d ", arr2[i]);
	}
	printf("\n");
	return 0;
}
#endif




#if 0
//计算斐波那契数列
int Fun(int seed)
{
	/*递归函数
	if (seed == 1 || seed == 2)
	{
		return 1;
	}
	else {
		return Fun(seed-1)+Fun(seed-2);
	}*/


	//迭代
	if (seed <= 2)
	{
		return 1;
	}
	else {
		int a = 1, b = 1, c = 0;//a、b是前两个数，c是当前数
		while (seed > 2)
		{
			c = a + b;
			a = b;
			b = c;
			seed--;
		}
		/*
		for(int i = 3; i <= seed; i++)
		{
			c = a + b;
			a = b;
			b = c;
		}
		*/
        return c;
	}
}

int main()
{
	int seed;
	printf("用户输入查询的斐波那契数列:>");
	scanf("%d", &seed);
	int ret = Fun(seed);
	printf("第%d个斐波那契数是%d\n", seed, ret);
	return 0;
}
#endif



#if 0
//编写一个函数实现n的k次方，使用递归实现。
double Pow(int n, int k)
{
	//如果指数幂为正整数
	if (k > 0) {
		return n * Pow(n, k - 1);
	}
	//如果指数幂为负整数，则可以取倒数，然后取正整数次方
	else if (k < 0) {
		return (1.0 / n) * Pow(n, k + 1);
	}
		//如果指数幂为0，则返回1
	else {
		return 1.0;
	}

	//特殊处理：
	// 1.当n为0时，0的0次方无意义，返回0
	//2.当n为0时，0的负数次方无意义，返回0
    //3.当n为负数时，负数的负数次方无意义，返回0
    //4.当n为负数时，负数的正数次方无意义，返回0
	if (n == 0 && k == 0)
		return 0;
    if (n == 0 && k < 0)
        return 0;
	if (n < 0 && k < 0)
        return 0;
    if (n < 0 && k > 0)
        return 0;
}

int main()
{
	int n, k;
    printf("请输入n和k:>");
	scanf("%d%d", &n, &k);
	double ret = Pow(n, k);
	printf("%d的%d次方是%lf\n", n, k, ret);
	return 0;
}

#endif


#if 0
//写一个递归函数DigitSum(n)，输入一个非负整数，返回组成它的数字之和
//例如，调用DigitSum(1729)，则应该返回1 + 7 + 2 + 9，它的和是19
//输入：1729，输出：19
#include <assert.h>
int DigitSum(int n)
{
    assert(n >= 0);//正整数通过
    if (n < 10)
		return n;
	else {
		return n % 10 + DigitSum(n / 10);
	}
}
int main()
{
	int n;
	printf("请输入一个正整数:>");
	scanf("%d", &n);
    int ret = DigitSum(n);
    printf("%d\n", ret);
	return 0;
}
#endif




#if 0
//求阶乘
#include <assert.h>
int SumMul(int n)
{
	assert(n >= 0);
	//求0和1的阶乘
	if (n == 0 || n == 1)
		return 1;
	else {
		return n * SumMul(n - 1);
	}

}
int main()
{
	int n;
	printf("请输入一个正整数:>");
	scanf("%d", &n);
	int ret = SumMul(n);
	printf("%d\n", ret);
	return 0;
}

#endif


#if 0
//递归方式实现打印一个整数的每一位
void Print(int n)
{
	
	//顺序打印
	if (n < 9)
	{
		printf("%d ", n);
	}
	else {
		Print(n / 10);

		printf("%d ", n % 10);
	}

	////逆序打印
	//if(n>9)
	//{
	//	printf("%d ", n % 10);
	//	Print(n/10);
	//	
	//}
	//else{
	//	printf("%d ", n);
	//}
	
}
int main()
{
	int n = 0;
	scanf("%d", &n);
	Print(n);
	return 0;
}
#endif



#if 0
void Bubblesort(int* arr, int seed)
{
	int i, j;
	//冒泡排序
	//趟数
	for (i = 0; i < seed-1; i++)
	{
		//比较次数
		for (j = 0; j < seed - 1 - i; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				int tmp= arr[j];
                arr[j] = arr[j + 1];
				arr[j+1]=tmp;
			}

		}
	}
}

void Print(int* arr, int seed)
{
	int i;
	for (i = 0; i < seed; i++)
	{
		printf("%d ", *(arr + i));
	}
}

int main()
{
	int arr[10] = { 0,100,23,53,39,20,2090,1000,2,3 };
	int seed = sizeof(arr) / sizeof(arr[0]);
	printf("原数组未排序:>");
	Print(arr, seed);
	Bubblesort(arr, seed);
	printf("\n");
	printf("排序后数组为:>");
	Print(arr, seed);

	return 0;
}
#endif



#if 0
//杨辉三角(自定义行数)

#include <stdlib.h>  

// 打印杨辉三角（二级指针动态管理二维数组）
void printYangHuiTriangle(int rows) {
	// 动态创建二维数组（通过二级指针管理指针数组实现）
	int** yanghui = (int**)malloc(rows * sizeof(int*));  // 先分配行指针
	if (yanghui == NULL) {  // 检查内存分配是否成功
		printf("内存分配失败！\n");
		return;
	}

	// 为每行分配存储空间（第 i 行有 i+1 个元素，可节省空间）
	for (int i = 0; i < rows; i++) {
		  yanghui[i] = (int*)malloc((i + 1) * sizeof(int));
		if (yanghui[i] == NULL) {
			printf("内存分配失败！\n");
			// 若某行分配失败，需释放已分配的内存
			for (int j = 0; j < i; j++) {
				free(yanghui[j]);
			}
			free(yanghui);//释放行指针数组
			return;
		}
	}

	// 填充杨辉三角
	for (int i = 0; i < rows; i++) {
		yanghui[i][0] = 1;               // 每行第一个元素为1
		yanghui[i][i] = 1;               // 每行最后一个元素为1

		// 填充中间元素（等于上一行左右两元素之和）
		for (int j = 1; j < i; j++) {
			yanghui[i][j] = yanghui[i - 1][j - 1] + yanghui[i - 1][j];
		}
	}

	// 打印杨辉三角（带居中空格）
	for (int i = 0; i < rows; i++) {
		//// 打印左侧空格，使三角形居中
		//for (int k = 0; k < rows - i - 1; k++) {
		//	printf("  ");
		//}
		// 打印当前行的元素
		for (int j = 0; j <= i; j++) {
			printf("%-2d", yanghui[i][j]);  // %-2d表示左对齐，宽度为2
		}
		printf("\n");
	}

	// 释放动态分配的内存（避免内存泄漏）
	for (int i = 0; i < rows; i++) {
		free(yanghui[i]);  // 先释放每行的内存
	}
	free(yanghui);  // 再释放行指针数组
}

int main() {
	int rows;
	printf("请输入杨辉三角的行数: ");
	scanf("%d", &rows);

	// 检查输入合法性
	if (rows <= 0) {
		printf("请输入正整数！\n");
		return 1;
	}

	printYangHuiTriangle(rows);
	return 0;
}
#endif



//力扣第二题：两数相加
#if 0
#include <stdlib.h>
struct ListNode {
	int val;
	struct ListNode* next;
};

//用递归处理两数之和
struct ListNode* SumTow(struct ListNode* l1, struct ListNode* l2, int carry) {
	//处理两链表为NULL的情况
	if (l1 == NULL && l2 == NULL && carry == 0)
		return NULL;
	int sum = carry;//用sum接受进位值,代表总和
	//处理l1的所有值的和
	if (l1)
	{
		sum += l1->val;
		l1 = l1->next;
	}
	if (l2)
	{
		sum += l2->val;
		l2 = l2->next;
	}
	//把l1和l2的链表值先加起来

	//创建和链表
	struct ListNode* l3 = (struct ListNode*)malloc(sizeof(struct ListNode));
	if (l3 == NULL)
	{
		printf("开辟失败\n");
		exit(1);
	}
  
	l3->val = sum % 10;//取值操作
	l3->next = SumTow(l1, l2, sum / 10);
	return l3;

}
struct ListNode* addTwoNumbers(struct ListNode* l1, struct ListNode* l2) {
	return  SumTow(l1, l2, 0);
}
// 辅助函数：打印链表
void printList(struct ListNode* head) {
	while (head != NULL) {
		printf("%d", head->val);
		if (head->next != NULL) {
			printf(" -> ");
		}
		head = head->next;
	}
	printf("\n");
}
int main()
{
	// 创建测试链表 l1: 2 -> 6 -> 4
	struct ListNode* l1 = (struct ListNode*)malloc(sizeof(struct ListNode));
	l1->val = 2;
	struct ListNode* node1 = (struct ListNode*)malloc(sizeof(struct ListNode));
	node1->val = 6;
	l1->next = node1;
	struct ListNode* node2 = (struct ListNode*)malloc(sizeof(struct ListNode));
	node2->val = 4;
	node1->next = node2;
	node2->next = NULL;

	// 创建测试链表 l2: 5 -> 7 -> 3
	struct ListNode* l2 = (struct ListNode*)malloc(sizeof(struct ListNode));
	l2->val = 5;
	struct ListNode* node3 = (struct ListNode*)malloc(sizeof(struct ListNode));
	node3->val = 7;
	l2->next = node3;
	struct ListNode* node4 = (struct ListNode*)malloc(sizeof(struct ListNode));
	node4->val = 3;
	node3->next = node4;
	node4->next = NULL;

	printf("链表1: ");
	printList(l1);
	printf("链表2: ");
	printList(l2);

	struct ListNode* result = addTwoNumbers(l1, l2);
	printf("结果: ");
	printList(result);
	return 0;
}
#endif





//拜佛图案
#if 0
void func() {
	printf("                            _ooOoo_  \n");
	printf("                           o8888888o  \n");
	printf("                           88  .  88  \n");
	printf("                           (| -_- |)  \n");
	printf("                            O\\ = /O  \n");
	printf("                        ____/`---'\\____  \n");
	printf("                      .   ' \\| |// `.  \n");
	printf("                       / \\||| : |||// \\  \n");
	printf("                     / _||||| -:- |||||- \\  \n");
	printf("                       | | \\\\\\ - /// | |  \n");
	printf("                     | \\_| ''\\---/'' | |  \n");
	printf("                      \\ .-\\__ `-` ___/-. /  \n");
	printf("                   ___`. .' /--.--\\ `. . __  \n");
	printf("                ."" '< `.___\\_<|>_/___.' >'"".  \n");
	printf("               | | : `- \\`.;`\\ _ /`;.`/ - ` : | |  \n");
	printf("                 \\ \\ `-. \\_ __\\ /__ _/ .-` / /  \n");
	printf("         ======`-.____`-.___\\_____/___.-`____.-'======  \n");
	printf("                            `=---='  \n");
	

}
void func2()
{
	printf("  \n");
	printf("         .............................................  \n");
	printf("                  佛祖镇楼                  BUG辟易  \n");
	printf("          佛曰:  \n");
	printf("                  写字楼里写字间，写字间里程序员；  \n");
	printf("                  程序人员写程序，又拿程序换酒钱。  \n");
	printf("                  酒醒只在网上坐，酒醉还来网下眠；  \n");
	printf("                  酒醉酒醒日复日，网上网下年复年。  \n");
	printf("                  但愿老死电脑间，不愿鞠躬老板前；  \n");
	printf("                  奔驰宝马贵者趣，公交自行程序员。  \n");
	printf("                  别人笑我忒疯癫，我笑自己命太贱；  \n");
	printf("                  不见满街漂亮妹，哪个归得程序员？\n");
}
int main() {

	// 函数调用
	func();
	func2();
	printf("\n");
	func();
	printf("\n");
	func();
	return 0;
}
#endif



////牛客网BC45：最高分是多少
//int main() {
//	int Chinese = 0;
//	int Math = 0;
//	int English = 0;
//	scanf("%d %d %d", &Chinese, &Math, &English);
//	int max = 0;
//	max= Chinese > Math ? Chinese : Math;
//    max = max > English ? max : English;
//
//	printf("%d\n", max);
//	return 0;
//}


//牛客BC23 时间转换
#if 0
int main() {
	int seconds = 0;
	scanf("%d", &seconds);
	int hour = seconds / 3600;
	int minute = seconds % 3600 / 60;
	int second = seconds % 3600 % 60;
	printf("%d %d %d", hour, minute, second);
	return 0;
}
#endif


//牛客——判断是否是元音字母
#if 0

int main()
{
	char ch = 0;
	while (scanf("%c", &ch) != EOF)
	{
		getchar();//吃掉回车
		if (ch == 'a' || ch == 'A' || ch == 'e' || ch == 'E' || ch == 'O' || ch == 'o' || ch == 'i' || ch == 'I' || ch == 'U' || ch == 'u')
			printf("Vowel\n");
		else
			printf("Consonant\n");
	}
	return 0;
}

#endif


//牛客——BC53 计算一元二次方程
#if 0
#include <math.h>

int main() {
	float a = 0.0f, b = 0.0f, c = 0.0f;
	float triangle = 0.0f, root1 = 0.0f, root2 = 0.0f, real = 0.0f, virtual = 0.0f;
	while (scanf("%f %f %f", &a, &b, &c) != EOF) {
		if (a == 0.0) {
			printf("Not quadratic equation\n");

		}
		else {
			triangle = (b * b - 4 * a * c);
			if (triangle > 0) {
				root1 = (-b - sqrt(triangle)) / (2.0 * a);
				root2 = (-b + sqrt(triangle)) / (2.0 * a);
				printf("x1=%.2f;x2=%.2f\n", root1, root2);
			}
			else if (triangle == 0) {
				root1 = root2 = (-b) / (2 * a);
				if (root1 == -0.0f)
				{
					root1 = 0.0f;
				}
				printf("x1=x2=%.2f\n", root1);
			}
			else {
				real = -b / (2 * a);
				virtual = sqrt(-triangle) / (2 * a);
				printf("x1=%.2f-%.2fi;x2=%.2f+%.2fi\n", real, virtual, real, virtual);

			}
		}
	}

	return 0;
}
#endif



//牛客——BC54 获得月份天数
#if 0
void days(int year, int month) {
	int arr[12] = { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
	//闰年月份天数
	int brr[12] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

	int day = 0;
	//判断闰年
	if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) {
		printf("%d\n", arr[month - 1]);
	}
	else {
		printf("%d\n", brr[month - 1]);
	}
}
int main() {
	int year = 0, month = 0;
	while (scanf("%d %d", &year, &month) != EOF) {
		days(year, month);
	}
	return 0;
}
#endif


//牛客——BC55 简单计算器
#if 0
//转移表
double Add(double a, double b)
{
	return a + b;
}
double Sub(double a, double b)
{
	return a - b;
}
double Mul(double a, double b)
{
	return a * b;
}


int main() {
	double(*calcu[4])(double, double) = { Add,Sub,Mul };
	double a = 0.0, b = 0.0;
	char ch = 0;
	scanf("%lf%c%lf", &a, &ch, &b);
	if (ch == '+')
	{

		printf("%.4lf+%.4lf=%.4lf\n", a, b, calcu[0](a, b));
	}
	else if (ch == '-') {
		printf("%.4lf-%.4lf=%.4lf\n", a, b, calcu[1](a, b));
	}
	else if (ch == '*') {
		printf("%.4lf*%.4lf=%.4lf\n", a, b, calcu[2](a, b));
	}
	else if (ch == '/') {
		if (b == 0.0)
		{
			printf("Wrong!Division by zero!\n");
		}
		else {
			printf("%.4lf/%.4lf=%.4lf\n", a, b, a / b);
		}

	}
	else {
		printf("Invalid operation!\n");
	}
	return 0;
}
#endif




#if 0
//牛客——BC62 翻转金字塔图案

int main() {
	int a = 0;
	while (scanf("%d", &a) != EOF)
	{
		if (a >= 2 && a <= 20)
		{
			for (int i = 0; i < a; i++)
			{
				for (int j = 0; j <= i; j++)
				{
					//空格
					printf(" ");
				}
				for (int j = 0; j < a - i; j++)
				{
					//字符打印
					printf("* ");
				}
				
				printf("\n");
			}
		}
	}
	return 0;
}
#endif



#if 0
//牛客——BC70 空心三角形图案
int main()
{
	int n = 0;
	while (scanf("%d", &n) != EOF)
	{
		for (int i = 0; i < n; i++)  //外循环为行
		{
			for (int j = 0; j < n; j++) //内循环为列
			{
				if (j == 0 || i == n - 1 || i == j)
					printf("* ");
				else
					printf("  ");
			}
			printf("\n");
		}
	}
}

#endif





#if 0
//牛客——BC76 公务员面试
#include <stdbool.h>

#include <stdlib.h>

int int_cmp(const void* n1, const void* n2) {
	return *(int*)n1 - *(int*)n2; // 升序排列
}

int main() {
	int i = 0;
	int arr[7] = { 0 };
	while (1) {
		for (; i < 7; i++) {
			// 先存入数字
			if (scanf("%d", &arr[i]) == EOF||arr[i]==0||arr[i]>100) {
				break;
			}
		}
		// 如果 i 为 0 ，说明没有读取到有效数据，直接退出（处理首次就是 EOF 的情况）
		if (i == 0) {
			break;
		}
		// 再进行排序判断头尾数
		qsort(arr, 7, sizeof(int), int_cmp);
		int sum = 0;
		// 直接排除小、大值，用 j 遍历
		for (int j = 1; j < 6; j++) {
			sum += arr[j];
		}
		double ave = sum / 5.0;
		printf("%.2lf\n", ave);
		// 重置 i ，为下一组输入做准备
		i = 0;
	}
	return 0;
}
#endif


#if 0
//牛客——BC77 有序序列插入一个数

int main() {
	int n;
	// 读取序列长度，题目限制 n 最大为 50，数组开 51 是为插入元素留空间
	scanf("%d", &n);
	int arr[51];
	for (int i = 0; i < n; i++) {
		scanf("%d", &arr[i]);
	}
	int num;
	scanf("%d", &num);

	// 二分查找确定插入位置
	int left = 0, right = n;
	int pos = n; // 初始设为数组末尾，若 num 比所有元素大，就插在最后
	while (left < right) {
		int mid = left + (right - left) / 2;//防止溢出
		if (arr[mid] >= num) {
			pos = mid;
			right = mid;
		}
		else {
			left = mid + 1;
		}
	}

	// 元素后移：从数组末尾开始，把插入位置及之后元素依次后移
	for (int i = n; i > pos; i--) {
		arr[i] = arr[i - 1];
	}
	// 插入新元素到 pos 位置
	arr[pos] = num;

	// 输出结果：按顺序打印 N + 1 个有序整数
	for (int i = 0; i <= n; i++) {
		printf("%d ", arr[i]);
	}
	return 0;
}
#endif

//牛客——BC89 密码验证
#if 0
#include <string.h>
int main() {
	char password[100] = { 0 };
	scanf("%s", password);
	char repeat[100] = {0};
	scanf("%s", repeat);
	if (strcmp(password, repeat)==0)
	{
		printf("same\n");
	}
	else {
		printf("different\n");
	}
	return 0;
}
#endif


//牛客——BC99 序列中整数去重
#if 0

int main() {
	int n = 0;
	int k = 0;
	int i = 0;
	int arr1[1000] = { 0 };
	int arr2[1000] = { 0 };
	scanf("%d", &n);
	for (i = 0; i < n; i++) {
		scanf("%d", &arr1[i]);
		int flag = 0; //标志位
		for (int j = 0; j < i; j++) {
			//第一个数永不重复
			if (arr1[i] == arr2[j]) {
				flag = 1;
				break;
			}
		}
		if (!flag) {
			//下标从0开始
			arr2[k++] = arr1[i];//用完下标后移动1位
		}
	}

	for (int j = 0; j < k; j++) {
		//遍历输入数组2里面元素即可
		printf("%d ", arr2[j]);
	}

	return 0;
}
#endif


//牛客——BC93 统计数据正负个数
#if 0
#include <stdlib.h>
int main() {
	int po = 0;
	int unpo = 0;
	int* arr = (int*)malloc(sizeof(int) * 10);
	if (!arr)
	{
		printf("malloc error!\n");
		return 0;
	}
	for (int i = 0; i < 10; i++)
	{
		scanf("%d", arr + i);
		if (*(arr + i) < 0)
		{
			++unpo;
			continue;
		}
		if (*(arr + i) > 0)
		{
			++po;
			continue;
		}
	}
	printf("positive:%d\n", po);
	printf("negative:%d\n", unpo);
	free(arr);
	arr = NULL;
	return 0;
}
#endif


//测试VS支持的部分C99特性
#if 0
#include <stdlib.h>
int main()
{
	int n = 0;
    scanf("%d", &n);
	int arr[6] = { [5] = 10 };//支持C99部分特性
	int arr3[n] = { 0 };//不支持变长数组
	int* arr2 = (int*)malloc(sizeof(int) * n);//动态分配内存
	for (int i = 0; i < 6; i++)
	{
		printf("%d ", *(arr + i));
	}
	free(arr2);
    arr2 = NULL;
	return 0;
}
#endif




//牛客——BC44 求最大公约数和最小公倍数的和问题
#if 0
#include <stdio.h>
// 求最大公约数
long long gcd(long long a, long long b) {
	long long c;
	while ((c = a % b) != 0) {
		a = b;
		b = c;
	}
	return b;
}
// 求最小公倍数
long long lcm(long long a, long long b) {
	return a * b / gcd(a, b);
}
int main() {
	long long n = 0, m = 0;
	scanf("%lld %lld", &n, &m);
	long long ret = lcm(n, m) + gcd(n, m);
	printf("%lld", ret);
	return 0;
}
#endif


//BC117 小乐乐走台阶(迭代算法)
#if 0
int countWays(int n) {
	if (n == 1) return 1;
	if (n == 2) return 2;

	int a = 1, b = 2, res;
	for (int i = 3; i <= n; i++) {
		res = a + b;
		a = b;
		b = res;
	}
	return res;
}

int main() {
	int n;
	scanf("%d", &n);
	printf("%d\n", countWays(n));
	return 0;
}
#endif


//BC111 小乐乐与进制转换(输入的是六进制转换过的数，要输出的是十进制的数)
#if 0

void six(int n)
{
	if (n > 5)
	{
		six(n / 6);
	}
	printf("%d", n % 6);
}
int main() {
	int n = 0;
	scanf("%d", &n);
	six(n);
	return 0;
}
#endif



//BC119 小乐乐与字符串(给你一个字符串s，你需要做的是统计s中子序列“CHN”的个数)
#if 0

int main() {
	char arr[8001] = { 0 };
	scanf("%s", arr);
	char* p = arr;
	long long c = 0, ch = 0, chn = 0;
	while (*p)
	{
		if (*p == 'C')
		{
			c++;
		}
		else if (*p == 'H') {
			ch += c;
		}
		else if (*p == 'N')
		{
			chn += ch;
		}
		p++;
	}
	printf("%lld", chn);
	return 0;
}
#endif





//BC136 KiKi去重整数并排序
#if 0

#include <stdlib.h>

int low_cpm(const void* n1, const void* n2)
{
	return *(int*)n1 - *(int*)n2;
}

int main() {
	int n = 0;
	int key = 0;//结果下标标识
	int sum = 0;//重复数据个数和
	scanf("%d", &n);
	int* arr = (int*)malloc(sizeof(int) * n);
	int* result = (int*)malloc(sizeof(int) * n);
	if (!arr)
	{
		printf("malloc fail");
		return -1;
	}

	for (int i = 0; i < n; i++)
	{
		scanf("%d", arr + i);
		int flag = 0;
		for (int j = 0; j < i; j++) {
			//排除第一个数字，因为结果数组为空，则第一个数字永远不同

			if (arr[i] == result[j])
			{
				flag = 1;//相同
				sum++;
				break;
			}
		}
		if (!flag)
		{
			//不同则原数组数复制到结果数组，结果数组下标++
			result[key] = arr[i];
			key++;
		}
	}

	//先排序再遍历结果数组即可
	qsort(result, n - sum, sizeof(int), low_cpm);

	for (int i = 0; i < n - sum; i++)
	{
		printf("%d ", *(result + i));
	}


	return 0;
}
#endif



#if 0
//函数指针 AND typedef
int Add(int a, int b)
{
	return a + b;
}
typedef int (*pintf)(int, int);//函数指针类型优化
int main()
{
	pintf p = Add;
	//函数指针类型:int (*)(int, int)
    printf("%d\n", p(1, 2));
	printf("%p\n", p);
    printf("%p\n", Add);
	//等价于printf("%d\n", Add(1, 2));
	return 0;
}
#endif



#if 0
#include <Windows.h>
int Add(int a, int b)
{
	return a + b;
}
int Sub(int a, int b)
{
	return a - b;
}
int Mul(int a, int b)
{
    return a * b;
}
int Div(int a, int b)
{
    return a / b;
}

typedef int(*parrf[])(int, int);

//enum Option {
//	Exit,//0
//    ADD,
//    SUB,
//    MUL,
//    DIV
//
//};

void Menu()
{
	printf("****************************\n");
	printf("********  Menu *************\n");
    printf("*****1.Add   2.Sub**********\n");
    printf("*****3.Mul   4.Div**********\n");
    printf("*****   0.Exit    **********\n");
    printf("****************************\n");

}
//函数指针数组 AND 回调函数  revise 
int main()
{
	parrf pf= {0,Add,Sub,Mul,Div};
	int input = 0;
	int x=0, y=0;
	do {
		Menu();
		printf("请输入选择计算器模式：\n");
		scanf("%d", &input);
		//优化掉Switch，因为case语句的部分多数相同，冗余
		/*switch (input)
		{
			case ADD:
				printf("请输入两个操作数:\n");
				scanf("%d %d", &x, &y);
				printf("两数相加的和为:%d\n",pf[0](x, y));
                break;
			case SUB:
				printf("请输入两个操作数:\n");
				scanf("%d %d", &x, &y);
                printf("两数相减的差为：%d\n",pf[1](x, y));
                break;
			case MUL:
				printf("请输入两个操作数:\n");
				scanf("%d %d", &x, &y);
                printf("两数相乘的积为：%d\n",pf[2](x, y));
				break;
            case DIV:
				printf("请输入两个操作数:\n");
				scanf("%d %d", &x, &y);
                printf("两数相除的商为：%d\n",pf[3](x, y));
				break;
            case Exit:
                printf("退出程序\n");
				system("pause");
				system("cls");
                break;
            default:
                printf("输入错误，请重新输入\n");
				system("pause");
				system("cls");
                break;
		}*/
		if (input > 0 && input < 5)
		{
			printf("请输入两个操作数:\n");
			scanf("%d %d", &x, &y);
			int ret = pf[input](x, y);
			printf("选择模式的最后得数为:%d\n", ret);
		}
		else if (input == 0)
		{
			printf("退出程序,欢迎下次使用\n");
			system("pause");
			system("cls");
		}
		else { 
			printf("输入错误，请重新输入\n");
		}

	}while (input);

	

	
	return 0;
}
#endif




#if 0
#include <windows.h>
#include <stdlib.h>

//设置光标的坐标
void SetPos(short x, short y)
{
	COORD pos = { x, y };
	HANDLE hOutput = NULL;
	//获取标准输出的句柄(⽤来标识不同设备的数值)
	hOutput = GetStdHandle(STD_OUTPUT_HANDLE);
	//设置标准输出上光标的位置为pos
	SetConsoleCursorPosition(hOutput, pos);
}



int main()
{
	////隐藏光标
	//HANDLE hOut = NULL;//句柄是指针类型
	//hOut = GetStdHandle(STD_OUTPUT_HANDLE);//获取标准输出句柄
	//CONSOLE_CURSOR_INFO cursor = { 0 };
	//GetConsoleCursorInfo(hOut, &cursor);//获取控制台光标信息
	//cursor.dwSize=75;//设置光标大小
	////cursor.bVisible = FALSE;//设置光标不可见
	//SetConsoleCursorInfo(hOut, &cursor);//设置控制台光标信息
#define PRESS_KEY(VIRTUAL_KEY) (GetAsyncKeyState(VIRTUAL_KEY) & 0x1) ? 1 : 0

// 定义按键和对应消息的映射表
	struct KeyMapping {
		char key;
		const char* message;
	};
	//映射表（可增添元素）
	struct KeyMapping keyMappings[] = {
		{'A', "按下了A键"},
		{'B', "按下了B键"},
		{'C', "按下了C键"},
		{'D', "按下了D键"},
		{'E', "按下了E键"},
		{'F', "按下了F键"},
		{'S',"按下了S键" },
		{'W',"按下了W键"}
	};

	const int keyCount = sizeof(keyMappings) / sizeof(keyMappings[0]);

	while (1) {
		for (int i = 0; i < keyCount; i++) {
			if (PRESS_KEY(keyMappings[i].key)) {
				printf("%s\n", keyMappings[i].message);
				break;//避免在同一帧内检测多个按键，确保每次循环只响应一个按键
			}
		}
		// 可以添加适当的延时避免过于频繁的检测
		Sleep(1000);
	}
	system("pause");
}
#endif


#if 0
//测试此编译器的默认模式是什么
#include <locale.h>
int main()
{
	char* local = setlocale(LC_ALL, NULL);
	printf("编译器默认模式是:%s\n", local);

	//执行编译器本地化操作
    setlocale(LC_ALL, "");
	printf("现在编译器的模式是%s\n", local);
    return 0;
}
#endif

#if 1
//打印宽字符和宽字符串
#include <locale.h>
int main()
{
	setlocale(LC_ALL, "");
	wchar_t ch = L'中';
	wchar_t* str = L"中华人民共和国";
	//wchar_t str[] = L"中华人民共和国";
	char* a = "ab";
	wprintf(L"%c\n", ch);
    wprintf(L"%ls\n", str);
    printf("%s\n", a);
	return 0;
}
#endif